Atari Forever 4/Atari Forever 4/Atari Forever 4.iso/PD_THEMA/CLI/COMMAND/COMMAND.TXT

Text File | 1998-03-14 | 114.3 KB | 2,882 lines

                                    -1-

Inhalt

1 Einleitung zu command.prg ........................................  3

2 Allgemeine Hinweise zur Befehlseingabe ...........................  4

3 Allgemeine Befehle ...............................................  7
  3.1 Besondere Befehle ............................................ 27
  3.2 Zahlkonvertierungen .......................................... 28

4 Die ALIAS-Einrichtung ............................................ 29
  4.1 Einführung ................................................... 29
  4.2 ALIAS-Befehlssatz ............................................ 29

5 Die History-Einrichtung .......................................... 31
  5.1 Einführung ................................................... 31
  5.2 Die !-Befehle ................................................ 33

6 Das Batch-Processing ............................................. 34
  6.1 Einführung ................................................... 34
  6.2 Befehlssatz .................................................. 34
  6.3 Beispiele .................................................... 41
    6.3.1 Bsp.1 .................................................... 41
    6.3.2 Bsp.2 .................................................... 42
    6.3.3 Bsp.3 .................................................... 43

7 Variablen ........................................................ 44
  7.1 Allgemeines zu den Variablen ................................. 46
  7.2 Beispiel ..................................................... 47
    7.2.1 Der File cc .............................................. 48

8 EDI .............................................................. 49
  8.1 Die Kommandos von EDI ........................................ 49

9 Fehlermeldungen .................................................. 51

10 Die Ausgabeumleitung ............................................ 54

11 Allgemeines Blabla zum Schluß ................................... 55
  11.1 Lieferumfang ................................................ 55
  11.2 Zur Programmierung .......................................... 55

12 ANHANG A (Befehlszusammenfassung) ............................... 58

13 ANHANG B (oldy-Beispiele) ....................................... 61
  13.1 Beispiel 1 für die Verwendung des oldy-Befehls .............. 61                                    -2-


  13.2 oldy, die Zweite ............................................ 62

14 Index ........................................................... 63


                                    -3-

1 Einleitung zu command.prg

command.prg ist ein Kommandointerpreter, der auf herkömmliche Art (à la
MS-DOS o.ä.), also ohne GEM oder ähnliche Bedienoberflächen, die Arbeit
mit dem ATARI unterstützen soll.  Er umfaßt die dafür üblichen  Befehle
wie z.B.  für das Filekopieren,  das Filelöschen oder die  Fileumbenen-
nung.
Einige Befehle wurden bei UNIX abgeschaut. Ein Teil der Historyeinrich-
tung findet in ähnlicher Form unter VMS Verwendung.  Die Befehle müssen
via  Tastatur  eingegeben  werden.  Es wird  zur  Benutzung  also  kein
Gebrauch von der Maus gemacht!
Über  die  bereits erwähnte Historyeinrichtung  ist  es  möglich,  alte
Befehle relativ einfach erneut aufzurufen,  ohne eine komplette Neuein-
gabe der Zeile vornehmen zu müssen.
Im  Folgenden  findet sich eine Zusammenstellung der  Befehle  mit  Be-
schreibung,  sowie eine Erklärung zu den zusätzlichen Features wie z.B.
das Batchprocessing.

Es versteht sich wohl von selbst,  daß ich für das korrekte Funktionie-
ren des Programms keine Garantie übernehme.  Datenverluste,  die  durch
auftretende  Programmfehler oder eine fehlerhafte Bedienung  verursacht
worden sind, hat jeder selbst zu verdauen!
Gefundene Fehler oder Probleme bitte ich an mich weiterzuleiten  (meine
Adresse steht im 'Allgemeinen Blabla'-Abschnitt).


                                    -4-

2 Allgemeine Hinweise zur Befehlseingabe

Die Eingabe eines Befehls kann mit Hilfe der Cursortasten,  der DELETE-
Taste, der ESC-Taste und der BACKSPACE-Taste korrigiert werden!

CONTROL-'<-' bzw. CONTROL-'->' bringen den Cursor an den Zeilenanfang /
das Zeilenende.

SHIFT-'->'  bzw.  SHIFT-'<-' bringen den Cursor ein Wort nach rechts  /
links.

CONTROL-X vertauscht das aktuelle mit dem folgenden Zeichen.

CONTROL-D löscht alle Zeichen vom Prompt bis zur Cursorposition.

INSERT expandiert einen Eingabestring,  wenn es einen File im aktuellen
Ordner gibt, der mit diesem String beginnt.

Man befindet sich übrigens die ganze Zeit in einem  Einfügemodus,  d.h.
beim  Korrigieren  einer  Zeile  werden  keine  Zeichen  überschrieben.
Überflüssige Zeichen müssen also explizit gelöscht werden!

Die ESC-Taste löscht die komplette Zeile. Die anderen Tasten haben ihre
übliche Funktion.

Viele  Befehle  erwarten mehrere Argumentangaben  oder  lassen  mehrere
Argumente zu.  Diese müssen jeweils durch einen Blank abgegrenzt  sein,
z.B.  würde "dir *.prg *.tos" zuerst alle PRG-Files und dann alle  TOS-
Dateien des aktuellen Verzeichnisses aufzeigen.

Dem  Benutzer älterer Versionen des Interpreters fällt vielleicht  auf,
daß  die Anmerkung nur Befehlseingaben in Kleinbuchstaben  vorzunehmen,
nicht  mehr  vorhanden ist.  Diese Restriktion habe  ich  entfernt.  Es
können jetzt Eingaben in Groß- und Kleinschreibung erfolgen.
Man muß allerding beachten,  daß bei einer Eingabe der erste String  in
Kleinbuchstaben umgewandelt wird,  die Argumentangaben bleiben unverän-
dert.

ACHTUNG!
Ich  bin inzwischen dazu übergegangen,  Befehle aus dem Interpreter  zu
entfernen.  Es handelt sich dabei ausnahmslos um Kommandos,  die  durch
andere einfach nachgebildet werden können (z.B.  hide). Der Grund liegt
einmal  in  der  Ersparnis von Speicher.  Das Programm  belegt  in  der
jetzigen Form mit Variablen und Pufferbereichen fast 100kB RAM. Es sind
bereits  Leute  gekommen,  die wegen  dieses  Umfangs  Speicherprobleme
bekommen haben. Zweitens hat die Vielfalt der Kommandos nicht besonders                                     -5-


zur Übersichtlichkeit beigetragen.  Es wurden aber wirklich nur doppelt
gemoppelte Kommandos entfernt. Die Beschreibung enthält an den relevan-
ten Stellen Hinweise, wie man diese Befehle nachbilden kann!

Bei  der folgenden Befehlsbeschreibung sind '[  ]'-Argumentangaben  als
optional zu verstehen und '< >' als zwingend. Sind Argumente z.B. durch
'(s)' als Plural gekennzeichnet,  bedeutet dies,  daß mehrere Argumente
angegeben werden können (nicht müssen).

Es  gibt  eine ganze Reihe von Fehlermeldungen,  die  es  dem  Benutzer
erleichtern  sollen,  einen Fehler bzw.  ein aufgetretenes  Problem  zu
erkennen. Durch die Verbindung einer Fehlermeldung mit einer Fehlernum-
mer,  ist  der  Benutzer von Batchdateien in der  Lage,  auf  bestimmte
Situationen individuell zu reagieren.

Eine  weitere  Fähigkeit  des Interpreters soll auch  schon  an  dieser
Stelle  Erwähnung  finden.  Man  kann von  ihm  aus  externe  Programme
aufrufen.  Kann  ein  eingegebenes Kommando nicht als  interner  Befehl
erkannt  werden,  wird versucht,  ob es ein Programm gibt,  daß  diesem
Befehlsnamen  entspricht.  Ist dies der Fall,  wird es aufgerufen  (das
bezieht  sich auf TOS,  TTP und PRG-Dateien).  Programme,  die sich  im
aktuellen Verzeichnis befinden und die aufgerufen werden sollen, müssen
nicht  mit  ihrem vollen Namen bezeichnet werden!  Es  wird  das  erste
Programm gestartet,  daß mit dem eingegebenen Teilstring  übereinstimmt
und eine der obigen Extensions hat.
Die  Einschränkung  mit  dem aktuellen Verzeichnis  besteht  ab  dieser
Version  nicht  mehr,  d.h.  auch  Programme aus  anderen  Ordnern  und
Laufwerken können via Teilstring aufgerufen werden!  Für die notwendige
Eindeutigkeit muß der Benutzer allerdings selber sorgen.
Soll  z.B.  ein Programm 'programm.tos' aufgerufen  werden,  genügt  es
'programm'  oder  sogar  noch weniger  Zeichen  einzugeben,  um  es  zu
starten.
Es  versteht sich wohl von selbst,  daß eingegebene Argumente an  diese
Programme weitergegeben werden.
Der  Benutzer kann mithilfe des path-Befehls bestimmte Suchpfade  ange-
ben,  die der Interpreter auf der Suche nach einem bestimmten  Programm
abklappert.

In  den Vorgängerversionen des Interpreters wurde nach dem  Lauf  eines
'.PRG'-Programms  der  Bildschirm  gelöscht.  Dieses  Verhalten  fanden
allerdings einige Leute nicht so besonders toll.  Aus diesem Grund wird
nun keine Löschung mehr vorgenommen.  Der Cursor befindet sich nach dem
Programmlauf in der letzten Zeile (die allerdings gelöscht wird). Ob es
nun  unter  Umständen  zu kleineren Unschönheiten  mit  dem  Mauszeiger
kommt, bleibt abzuwarten.
                                    -6-


Die Befehle in der folgenden Beschreibung sind durch ein  vorangestell-
tes '->' und eine einfache Unterstreichung kenntlich gemacht.

Da es zahlreiche Kommandos gibt, die nur durch eine Abkürzung repräsen-
tiert sind (z.B.  cp für copy), werden dort die vollständige Ausschrei-
bung  der  Kommandos angegeben.  Dies scheint mir für  ein  einfacheres
Einprägen der Befehle förderlich zu sein.

Durch häufigen Gebrauch von Beispielen habe ich versucht,  die  Befehle
und  ihre  Funktion transparenter zu machen.  Einige  dieser  Beispiele
enthalten Hinweise, die zu einer bequemeren Handhabung des Interpreters
führen  sollen.  Es  ist  daher nicht ganz  sinnlos,  sich  mit  diesem
zusätzlichen Geschwafel auseinanderzusetzen.


                                    -7-

3 Allgemeine Befehle

-> ?ok
Diesen Befehl und den zugehörigen File checksum.dat gibt es nicht mehr.
Es  konnte praktisch jeder die Zahl in der angesprochenen Datei  ändern
und  so  eine Warnung provozieren,  also hat das Kommando  seinen  Sinn
leider  verfehlt.  Ich möchte an dieser Stelle noch auf die  inzwischen
doch  recht  zahlreich  vorhandenen  PD-Programme  hinweisen,  die  ein
Erkennen von Viren zulassen. Die Verwendung eines solchen Programms sei
jedem nur wärmstens empfohlen!

-> bell
Dieser  Befehl läßt den ATARI einmal 'klingeln'.  Man kann  mit  diesem
Kommando z.B.  das Ende einer Batchfilebearbeitung akustisch  hervorhe-
ben.

-> cat <file(s)>
(kompletter Name: concatenate)
Gibt  den  Inhalt eines ASCII-Text-Files auf den  Bildschirm  aus.  Die
Ausgabe  kann jederzeit mit ^Z abgebrochen werden.  Der Befehl  erlaubt
es, mehrere Dateien anzugeben.
Beim Versuch z.B.  eine Programmdatei auszugeben,  bricht natürlich das
Chaos aus!
Durch  F1  (damit  ist die Funktionstaste  gemeint)  kann  die  Ausgabe
angehalten  werden,  durch  erneuten  Druck  auf  F1  wird  sie  wieder
fortgesetzt.
Man  kann  dieses Kommando übrigens auch auf andere  Verzeichnisse  und
Laufwerke anwenden!
BEISPIEL:

                                cat *.c

Hier werden alle 'C'-Dateien ausgegeben.

                    cat command.txt test.txt *.dat

Es  wird  erst  der  File  'command.txt'  ausgegeben,  dann  die  Datei
'test.txt' und zum Schluß alle 'dat'-Files.

                            cat /test/*.dat

Ausgabe aller 'dat'-Files, die sich im Ordner 'test' befinden.

-> cd <directory>
(kompletter Name: change directory)
Dieses Kommando wird zum Wechseln von Verzeichnissen benutzt.                                    -8-


Soll zu einem Ordner gewechselt werden, der sich im aktuellen Directory
befindet,  genügt es,  die ersten Buchstaben (bis Eindeutigkeit  herge-
stellt ist), einzugeben.
Es  wird  immer  das erste Verzeichnis  angesprungen,  daß  mit  diesem
Teilstring übereinstimmt.
Es ist ab und zu schon vorgekommen,  daß beim Wechseln von  Laufwerken,
zwar so getan wird,  als hätte ein solcher stattgefunden, man sich aber
in  Wirklichkeit  immer  noch an der  gleichen  Stelle  befindet.  Hier
scheint es ein Problem im TOS zu geben (GEMDOS-Routine Dsetdrv). Dieses
Verhalten habe ich allerdings bisher nur bei Floppylaufwerken  beobach-
ten  können.  Ramdisks  oder  verschiedene  Partitions  einer  Harddisk
bereiten keine Probleme. Ich möchte mit diesem Hinweis allerdings nicht
sagen, daß jetzt dauernd mit dieser Nichtwechselei zu rechnen ist, also
keine Panik!
BEISPIEL:

                               cd subdir

Wechselt vom aktuellen Verzeichnis in das Unterverzeichnis 'subdir'.

                              cd a:bingo

Wechselt das Laufwerk,  vom aktuellen Laufwerk auf Laufwerk A, und geht
dort in den Ordner 'bingo'.

                                 cd ..

Vom  aktuellen Unterverzeichnis wird in das Verzeichnis  gegangen,  daß
sich eine Ebene über dem Unterverzeichnis befindet.  Verhält sich  also
analog zu einem Anklicken der oberen linken Fensterecke unter GEM.

                           cd / (oder cd \)

Wechselt in das Wurzelverzeichnis des aktuellen Laufwerks.

                                 cd d:

Wechselt  nur das Laufwerk.  Die Eingabe von 'd:' bewirkt übrigens  das
gleiche (s.u.).

-> chmod <file> <mode> ... <file> <mode>
(kompletter Name: change mode)
Dieser Befehl kann zur Änderung von Fileattributen benutzt werden.  Bei
den  Fileangaben kann mit '*' gearbeitet werden.  'mode'  repräsentiert
eine Integerzahl, die das neue Attribut darstellt.
Man sollte bei Verwendung dieses Befehls etwas Vorsicht walten  lassen.                                     -9-


Ich  habe  z.B.  mal aus einem normalen auto.com-File  ein  Volumelabel
gemacht.  Leider  hat die Rückführung in eine normale Datei nicht  mehr
funktioniert.  Das  Betriebssystem ist hier leider ziemlich  restriktiv
ausgelegt!
Es ist mir bis jetzt auch noch nicht gelungen,  Verzeichnissen z.B. das
read  only-Attribut  zu  vergeben  (was  ja  als  Schutzfunktion  recht
nützlich  wäre).  Irgendwie hat man auf solche Einträge keinen  Zugriff
via Fattrib().
An dieser Stelle ist eine Zusammenstellung der Bits und ihrer Bedeutung
wohl ganz hilfreich:
     Bit 0: Datei ist schreibgeschützt
     Bit 1: Datei ist versteckt (wenigstens ein bißchen)
     Bit 2: es handelt sich um eine Systemdatei (habe bis jetzt noch
            keine gefunden)
     Bit 3: Volumelabel (kann man z.B. beim Formatieren angeben)
     Bit 4: Verzeichnis
     Bit 5: ist das Archivbit (Kennung wc)
Um  die  entsprechende Eigenschaft zu besitzen muß  das  jeweilige  Bit
gesetzt sein!
BEISPIEL:

                             chmod *.prg 1

Allen  PRG-Dateien  im  aktuellen Ordner wird  das  nur  lesen-Attribut
verliehen.

                         chmod *.prg 1 *.txt 0

PRG-Files werden mit dem nur lesen-Attribut,  TXT-Dateien erhalten  das
normale Schreiben/Lesen-Attribut.

-> cls
(kompletter Name: clear screen)
Es wird mit diesem Befehl nur der Bildschirm gelöscht.

-> cmp <fileA> <fileB>
(kompetter Name: compare)
Vergleicht den Inhalt zweier Files miteinander. Ist dieser gleich, wird
nichts zurückgemeldet, ansonsten ein files differ.
Es ist bei diesem Befehl möglich,  sich auf andere Laufwerke und andere
Ordner zu beziehen.
Wem  es  ab  und  zu schon passiert  ist,  daß  ein  scheinbar  korrekt
abgelaufener  Kopiervorgang  doch nicht so  recht  funktionierte,  wird
diesen Befehl zu schätzen wissen.
                                    -10-

BEISPIEL:

                    cmp c:command.txt a:command.txt

Vergleich der beiden Dateien, die sich auf unterschiedlichen Laufwerken
befinden.

                      cmp command.txt command.txt

Dieser Befehl wird nicht ausgeführt,  da davon auszugehen ist,  daß  es
sich um ein und denselben File handelt.

-> compress <file(s)>
Dieses  Kommando  komprimiert Dateien.  Die Ausgabefiles  besitzen  die
Extension 'CPR'.
Die ursprünglichen Files werden mit expand wieder erzeugt.
Das  Ergebnis  der  Kompaktierung ist alles in  allem  nicht  besonders
berauschend, aber ein bißchen schaut schon dabei heraus.
Sollte  jemand  auf  eine wirklich  effektiv  arbeitende  Kompaktierung
angewiesen  sein,  so möchte ich diesen auf Programme wie ARC oder  ZOO
verweisen.
Ältere  Versionen  des Kommandointerpreters konnten  nur  reine  ASCII-
Textdateien packen. Diese Einschränkung gilt nicht mehr. Dieser Vorteil
hat allerdings einen kleinen Haken,  redundante Texte wie z.B. Leerzei-
len,  die  nur Blanks enthalten oder Zeilen,  die mit Blanks  aufhören,
werden  nicht mehr entfernt!  Nach der Erweiterung mit expand  hat  man
also wieder den ursprünglichen File vor sich.
Das  Verfahren,  das  hinter diesem Kommando steht  ist  übrigens  ganz
einfach: es werden alle Strings, die aus mehr als zwei gleichen Zeichen
bestehen, zu drei Byte-Strings zusammengefaßt.
Besonders  gute  Opfer  für diesen Befehl sind mit  dem  Editor  TEMPUS
erstellte Dateien.  Da dieser leider nicht in der Lage ist,  vernünftig
mit  TAB-Zeichen  umzugehen  (und  stattdessen  das  idiotische  ATARI-
spezifische  Zeichen bzw.  die eingestellte Anzahl von  BLANKs  macht),
bringt hier die Komprimierung schon einige Bytes an Ersparniss.  Sollte
irgendwann  einmal  eine  Version  dieses,  ansonsten  wirklich  guten,
Editors herauskommen,  die eine brauchbare Einbindung und  Verarbeitung
von TAB beinhaltet,  bringt die Komprimierung natürlich auch nicht mehr
diese Ergebnisse.
BEISPIEL:

                         compress beispiel.txt

Kompaktiert   die  Datei  'beispiel.txt'.   Der  erzeugte  File   heißt
'beispiel.cpr'. 'beispiel.txt' selbst wird nicht verändert!
                                    -11-


-> cp <fileA> <fileB>
(kompletter Name: copy)
Dieser Befehl wird zum Kopieren von Dateien benutzt. 'fileA' wird dabei
in 'fileB' kopiert.
Der Befehl ist so ausgelegt,  daß in weitem Umfang auf andere Laufwerke
und  Verzeichnisse  zugegriffen werden kann.  Die  Verwendung  von  '*'
bietet ein zusätzliches Maß an Flexibilität.
Während  dem Kopiervorgang wird angezeigt,  welche Files gerade  dupli-
ziert werden.
Sicherheitshalber  sollte beim Kopieren in oder aus Verzeichnissen  der
vollständige Pfad angegeben werden!
Wird  nur ein Argument angegeben,  so ersetzt das Programm  das  zweite
durch '*.*'.
BEISPIEL:

                    cp c:command.txt d:\subdir\*.*

In  diesem Beispiel wird der File 'command.txt' vom Hauptdirectory  auf
Laufwerk C in das Subdirectory 'subdir' auf Laufwerk D kopiert.
Es kann übrigens statt '\' auch '/' verwendet werden.

                              cp *.prg a:

Kopiert alle PRG-Dateien des aktuellen Verzeichnisses auf Laufwerk A.

                        cp *.* d:/allefiles/*.*

Hier  werden  alle  Files  des  aktuellen  Ordners  in  das   Directory
'allefiles' auf Laufwerk D kopiert.

                             cp c:xyz.dat

Der File 'xyz.dat' wird vom Laufwerk C in das Verzeichnis  kopiert,  in
dem man sich gerade befindet.  Der Name der neuen Datei ist dabei  auch
wieder 'xyz.dat'.

-> crsoff
(kompletter Name: cursor off)
Schaltet den Cursor aus.

-> crson
(kompletter Name: cursor on)
Schaltet den Cursor ein.

-> crypt <keyA> <keyB> <fileA> <fileB>
Möchte  man einen File ver- bzw.  entschlüsseln,  so kann  dazu  dieser                                     -12-


Befehl benutzt werden.  Um diesen Kodierungsvorgang zu starten,  ist es
notwendig,  zwei Zahlen ('keyA' und 'keyB') einzugeben.  Nur mit diesen
beiden Zahlen kann ein verschlüsselter File wieder dekodiert werden!
'fileA' stellt den zu ver- /entschlüsselnden File dar,  'fileB'  reprä-
sentiert die Ergebnisdatei.
ACHTUNG, im Laufe der Zeit (oder besser: der Interpreterversionen) sind
an diesem Programmteil immer wieder Änderungen vorgenommen  worden!  Es
ist daher für Benutzer dieses Befehls notwendig,  festzustellen ob  ein
Entschlüsseln von Dateien,  die mit einer älteren Version verschlüsselt
worden  sind,  noch  möglich ist.  Kann dies  nicht  mehr  durchgeführt
werden, muß man den fraglichen File erst mit der älteren Version wieder
in seinen Urzustand bringen!
Wie sicher die Kodierung ist,  mag jeder selbst entscheiden. Die beiden
Schlüssel sind vom Typ 'long',  damit ergeben sich schon einige  Kodie-
rungsmöglichkeiten. Es können übrigens auchg negative Schlüssel benutzt
werden.
BEISPIEL:

                crypt 123 4711 command.txt command.crp

Die   Datei  'command.txt'  wird  in  verschlüsselter  Form   im   File
'command.crp'  abgelegt.  Soll aus 'command.crp' wieder der  entschlüs-
selte File entstehen, muß einfach

                crypt 123 4711 command.crp command.ent

eingegeben werden.  'command.ent' repräsentiert nun den entschlüsselten
File.  Es  hätte  natürlich auch irgendein  anderer  Dateiname  gewählt
werden können.
Der Urfile (in diesem Fall 'command.txt') wird übrigens weder  gelöscht
noch sonst irgendwie verändert!

-> date [dd.mm.yy]
Ausgabe/Setzen des Datums.
Wird kein Argument angegeben,  wird einfach das Systemdatum ausgegeben,
sonst erfolgt eine Übernahme des Arguments.
BEISPIEL:

                              date 1.5.88

Setzt das Systemdatum auf den 1. Mai 1988.

                                 date

Hier wird nur das Systemdatum ausgegeben.
                                    -13-


-> defkey <f-key> <string>
(kompletter Name: define key)
Belegung der Funktionstasten mit einem Befehl,  der bei Drücken  dieser
Tasten ausgeführt wird.
'f-key'  umfaßt  den  Bereich von 1 bis 20 (na ja,  es  gibt  halt  nur
zwanzig  Funktionstasten),  wobei ab Nummer 11 die  geshifteten  Tasten
gemeint sind, also wird z.B. Taste 14 duch SHIFT-F4 repräsentiert.
BEISPIEL:

                          defkey 1 dir *.prg

Jeder  Druck  auf  F1 führt jetzt zum Aufzeigen  aller  PRG-Dateien  im
aktuellen Verzeichnis.
Die Hauptanwendung für diese Funktion dürfte allerdings im Aufrufen von
externen Programmen mit bestimmten Parametern liegen:

                            defkey 12 x.prg

F12 (SHIFT-F2) führt nun zum Starten des Programms 'x.prg'.

-> device
Ausgabe der angemeldeten Laufwerke.

-> df
(kompletter Name: disk free)
Dieses Kommando zeigt den freien Speicherplatz des aktuellen  Laufwerks
an.

-> dir [filedeskriptor(en)]
(kompletter Name: directory)
Aufzeigen  aller  (bestimmter) Dateien eines Ordners.  Es  können  auch
Laufwerksbezeichnungen bzw. Ordner angegeben werden.
Wird  kein  Deskriptor angegeben,  werden alle  Files  ausgegeben.  Bei
Angabe  mehrerer Deskriptoren,  werden sukzessive  alle  entsprechenden
Dateien aufgezeigt.
Zusätzlich  zu den Filename erfolgt eine Ausgabe von  Erstellungsdatum,
Größe und Fileattribut.
Die Attribute werden sowohl in abgekürzter Form,  als auch als Integer-
wert (in Klammern) ausgegeben.  Die Attributabkürzungen und ihre Bedeu-
tung:

          - rw = Read and Write
          - ro = Read Only
          - hi = HIdden
          - sf = System File
          - vl = Volume Label                                    -14-


          - di = DIrectory
          - wc = Written and Closed

Natürlich kann ein File mehrere Attribute haben (z.B.  wc und  hi).  Es
werden dann alle aufgeführt.
BEISPIEL:

                                  dir

Ausgabe aller Dateien des aktuellen Verzeichnisses.

                                dir a:

Ausgabe aller Files vom aktuellen Ordner auf Laufwerk A.

                            dir *.prg a*.*

Ausgabe aller PRG-Files und danach aller Dateien, die mit 'a' beginnen.

                           dir /megamax/

Ausgabe aller Dateien im Verzeichnis 'megamax'.

-> echo [string]
Ausgabe  von 'string' auf den Bildschirm.  Wird kein String  angegeben,
erfolgt nur die Ausgabe einer Leerzeile.
Sinnvoll ist dieses Kommando in Batchfiles.
BEISPIEL:

                            echo Na prima!

Es wird 'Na prima!' ausgegeben.

-> exit
Verlassen des Interpreters und zurück zum Desktop. Das gleiche kann man
auch durch Drücken von ^C erreichen.

-> expand <file(s)>
Dieser  Befehl  stellt  die Umkehrung zu compress  dar.  Er  dient  der
Wiederherstellung von mit compress behandelter Dateien.  Der  Ergebnis-
file hat die Extension 'EXP'.

-> find <file>
Es wird im kompletten Filesystem (also auch in den Unterverzeichnissen)
nach 'file' gesucht.  Wird eine passende Datei gefunden, wird diese mit
vorangestelltem Pfadnamen ausgegeben.                                    -15-


BEISPIEL:

                               find *.*

Dieses  Kommando würde alle Files eines Laufwerks mit  den  zugehörigen
Verzeichnisnamen ausgeben.

                              find *.prg

Dieser  Befehl  gibt alle PRG-Files aus,  die sich  auf  dem  aktuellen
Laufwerk befinden.

-> flags
Ausgabe diverser Programmflags.  Diese Flags werden später,  bzw. immer
bei  den Befehlen für die sie relevant sind,  noch eingehender  bespro-
chen.
Zuordnung der Kommandos:

     "Errorbreak"                  Befehl:errorbreak
     "History"                     Befehl:srhist
     "ß = Beta"                    Befehl:sz
     "Patch change"                Befehl:pchange
     "Show batch commands"         Befehl:text/notext
     "Save history"                Befehl:savehist
     "Print title"                 Befehl:srtitle
     "Expand TAB"                  Befehl:srtab
     "Convert slash"               Befehl:slash
     "Line numbers"                Befehl:numbers

Bei  diesen  Flags wird durch on/off angezeigt,  ob  die  Funktion  des
entsprechenden Befehls aktiviert ist oder nicht.

Die folgende Auflistung zeigt die Verbindung von Kommandos,  die  SetUp
Funktion haben und ihre Representation in der Flag-Liste:

     "TAB"                         Befehl:settab
     "Lines per page"              Befehl:lppage
     "Margin"                      Befehl:lpmargin
     "Start page"                  Befehl:page
     "start:"                      Befehl:setlp
     "stop :"                      Befehl:resetlp

-> free
Gibt den noch verfügbaren RAM-Speicherplatz aus.

                                    -16-

-> head <file(s))
Dieser  Befehl gibt die ersten zehn Zeilen der/des  angegebenen  ASCII-
Files aus. Damit kann man sich auf recht einfache Weise einen Überblick
über bestimmte Fileinhalte verschaffen.
BEISPIEL:

                               head *.c

Ausgabe der ersten zehn Zeilen aller 'c'-Dateien die sich im  aktuellen
Ordner befinden.

                           head e:/subdir/datei.txt

  Ausgabe  der ersten zehn Zeilen von Datei 'datei.txt',  die  sich  im
Ordner 'subdir' auf Laufwerk E befindet.

-> help [command(s)]
Wird  dieser Befehl ohne Argument(e) eingegebe oder einfach  die  HELP-
Taste  gedrückt,  erfolgt eine Auflistung aller verfügbaren  Kommandos.
Diese  Auflistung  ist (leider) nicht  alphabetisch  geordnet,  sondern
entspricht der Reihenfolge in der neue Befehle dem Programm hinzugefügt
worden  sind.  Das ist zwar nicht besonders schön aber zum  Verschaffen
eines  kurzen Überblicks dürfte es wohl genügen und  die  programmtech-
nischen Änderungen zum Ausgeben einer geordneten Liste,  steht wohl  in
keinem sinnvollen Verhältnis zum Nutzen.
Wird allerdings ein Argument (oder mehrere) angegeben,  so erfolgt  die
Ausgabe einer Kurzbeschreibung.
Diese Beschreibungen befinden sich in der Datei command.hlp,  die  sich
immer  in  dem Verzeichnis befinden muß,  von dem aus  der  Kommandoin-
terpreter aufgerufen wurde.
BEISPIEL:

                              help dir rm

Es  werden die Kurzbeschreibungen zu den Kommandos dir und rm  ausgege-
ben.

-> hide <file>
Wolltte  man einen File so kennzeichnen,  daß er auf dem Desktop  nicht
mehr erschien,  konnte dies in älteren Interpreterversionen mit  diesem
Befehl bewerkstelligt werden. Dieses Kommando gibt es nicht mehr!
Möchte jemand trotzdem Dateien verstecken,  kann er dies unter  Verwen-
dung von chmod tun.  Es muß bei den Dateien Bit 1 (dezimal = 2) gesetzt
sein,  um eine hide-Kennzeichnung zu erreichen, bzw. muß dieses Bit bei
normal sichtbaren Dateien gelöscht sein.  Das ganze mit dem  Verstecken
funktioniert allerdings nur,  wenn wirklich nur dieses eine Bit gesetzt                                     -17-


ist!
Um  eine Datei entsprechend zu kennzeichnen,  muß man also  in  Zukunft
"chmod <datei> 2" verwenden.
Ich habe dieses Kommando entfernt,  da es einige Leute gab,  die lieber
ein  kürzeres Programm haben wollten und dafür  auf,  zugegebenermaßen,
überflüssige Befehle zu verzichten bereit waren.

-> inverse
Die  Bildschirmdarstellung wird invertiert,  d.h.  war vor Eingabe  des
Befehls die normale Darstellung,  also schwarz auf weiß,  aktiv, so ist
die  Darstellung  nun  weiße  Schrift  auf  schwarzem  Grund.  War  die
Darstellung weiß auf schwarz,  wird wieder auf die normale  Einstellung
umgeschaltet.
Es gibt einige Programme,  die für eine Invertierung der Bildschirmdar-
stellung  sorgen ohne den Originalzustand wieder  herzustellen.  Dieses
Manko wird durch inverse aufgehoben.

-> keyboard
Ausgabe  der  Kommandos,  die zum Editieren der Eingabe  zur  Verfügung
stehen.

-> keys
Dieser  Befehl sorgt für eine Auflistung der  Funktionstastenbelegungen
(vgl. defkey).

-> lock
Möchte  man  den Rechner eine Weile angeschaltet  stehen  lassen,  aber
gleichzeitig Sorge dafür tragen,  daß ihn kein anderer benutzt, so kann
dies mit lock gemacht werden.
Nach Eingabe des Kommandos wird der Benutzer aufgefordert, ein Passwort
einzugeben. Zur Bestätigung muß diese Eingabe wiederholt werden. War es
jedesmal  das gleiche Wort,  meldet der Rechner,  daß er  abgeschlossen
(locked)  ist.  Will  man nun weiterarbeiten,  muß einfach  erneut  das
Passwort  eingegeben werden.  Ist es falsch,  erfolgt  keine  Reaktion,
sonst erscheint wieder der normale Prompt.
Ein Knacken des Schutzes kann übrigens durch die RESET-Taste oder durch
einfaches Aus-/Einschalten erfolgen (klar, oder?).

-> lp <file(s)>
(kompletter Name: lineprinter)
Soll  eine  ASCII-Datei  (oder mehrere) auf  einem  Drucker  ausgegeben
werden,  geschieht dies durch dieses Kommando.  Hat man einen  Drucker-
spooler in Betrieb, ist das eine recht nette Angelegenheit.
Außerdem gibt es bei Verwendung von lp keine Probleme mit  TAB-Zeichen,
da  sie  korrekt expandiert werden (wenn gewünscht).  Es  ist  außerdem
möglich,  eine Titelseite auszugeben und vor dem eigentlichen  Ausdruck                                     -18-


und nach dessen Abschluß, eine Steuersequenz an den Drucker zu schicken
(vgl. auch settab, srtitle, setlp und resetlp).
Ein Stoppen des Druckvorgangs kann jederzeit mit ^Z ausgelöst werden!
BEISPIEL:

                            lp command.txt

Ausdruck der Datei 'command.txt'.

-> lpmargin [intvalue]
(kompletter Name: lineprinter margin)
Anzahl  der Blanks,  die bei einem Ausdruck vor der eigentlichen  Zeile
kommen. Fehlt das Argument, ist diese Funktion ausgeschaltet.

-> lppage [intvalue]
(kompletter Name: lineprinter page)
Anzahl  der  Zeilen pro Seite bei einem Ausdruck.  Wird  kein  Argument
angegeben, ist diese Funktion ausgeschaltet.
Bei eingeschalteter Funktion,  wird jeweils nach Erreichen der  Zeilen-
zahl ein Seitenvorschub durchgeführt.

-> ls [filedeskriptor(en)]
(kompletter Name: list short)
Dieser  Befehl  ist eine Abart von dir.  Dort  wird  eine  ausführliche
Informationsfolge  zu jedem File mit ausgegeben.  Dies unterbleibt  bei
ls. Hier werden nur die Datei- bzw. Ordnernamen aufgelistet.

-> merge <fileA> <fileB>
Dieses Kommando wird zur Verbindung von zwei ASCII-Files benutzt. Dabei
wird 'fileB' an 'fileA' angehängt. 'fileB' wird nicht modifiziert!
'fileA' und 'fileB' dürfen nicht die gleiche Datei darstellen, d.h. der
Befehl "merge command.txt command.txt" würde nicht funktionieren!

-> mkdir <dirname>
(kompletter Name: make directory)
Dieser Befehl erzeugt einen neuen Ordner.  Man sollte allerdings  nicht
vergessen,  daß nur eine bestimmte Verzeichnistiefe zulässig ist.  Auch
das '40-Ordner-Problem' sollte man im Auge behalten.
Nach der Generierung des neuen Verzeichnisses,  findet man dort bereits
zwei Einträge,  nämlich '..' und '.'. '.' stellte einen Verweis auf den
Ordner  dar,  '..' ist ein Verweis auf das darüberliegende  Verzeichnis
(vgl auch "cd ..").
                                    -19-

BEISPIEL:

                             mkdir schrott

Es  wird  im aktuellen Directory das  neue  Unterverzeichnis  'schrott'
eingerichtet.  Mit  "cd  schrott" und dir kann  man  anschauen,  welche
Dateien dabei erzeugt worden sind ('.' und '..', welche sonst?).

-> more <file(s)
Ähnlich  dem  cat-Kommando können mit diesem Befehl eine  oder  mehrere
ASCII-Dateiinhalte  auf den Bildschirm ausgegeben  werden.  Der  Unter-
schied zu cat liegt darin,  daß immer nur eine Bildschirmseite ausgege-
ben wird. Dann wird angehalten und auf das Drücken der SPACE-Taste bzw.
von  RETURN gewartet.  Wird SPACE betätigt,  erfolgt die Ausgabe  einer
neuen Seite, bei RETURN wird zeilenweise fortgefahren.
Die Ausgabe kann jederzeit mit ^Z abgebrochen werden.
Das  Kommando  erlaubt den Zugriff auf Dateien,  die  sich  in  anderen
Ordnern / auf anderen Laufwerken befinden.
BEISPIEL:

                              more *.pas

Es werden sämtliche Pascalsourcefiles ausgegeben (ich gehe dabei  davon
aus, daß die Extension 'PAS' sich auf PASCAL bezieht).

                        more c:/duplikat/com.c

Ausgabe  des  Files  'com.c' der sich auf  Laufwerk  C  im  Verzeichnis
'/duplikat/' befindet.

-> mouseoff
Der Sinn dieses und des nächsten Befehls mag auf den ersten Blick nicht
einleuchten, aber es steckt trotzdem einer dahinter.
Das Kommando schaltet den Mauszeiger aus.  Normalerweise ist im  Inter-
preter  dieser Zeiger sowieso nicht sichtbar.  Es gibt aber  Programme,
die  diesen  Zeiger sehr wohl benutzen,  und hängt sich nun  solch  ein
Programm auf, kann es unter Umständen zu einem herrlichen Durcheinander
mit der Maus kommen.
Wird z.B.  ein Programm mit der Extension PRG aufgerufen,  schaltet der
Interpreter  automatisch  den Mauszeiger vor  dem  Programmaufruf  ein.
Schaltet dieses Programm nun diesen Zeiger wieder aus und ihn auch  bei
erreichen  des  Programmendes nicht wieder ein  (wie  es  gentlemanlike
wäre),  so  gibt  es Probleme,  da der Interpreter nach  dem  Lauf  des
Programms den Zeiger abschaltet,  und zwar unabhängig davon, ob er ein-
oder ausgeschaltet war.
Ich  nehme  mal an,  daß die Problematik bis jetzt noch nicht  so  ganz                                     -20-


einleuchtet,  schließlich will man ja, daß der Mauszeiger verschwindet.
Leider ist das GEM aber so organisiert,  daß es sich merkt, wie oft der
Zeiger ausgeschaltet worden ist,  d.h.  wird er zweimal  ausgeschaltet,
muß er, um wieder sichtbar zu werden, auch wieder zweimal eingeschaltet
werden.  Der Interpreter hat nun aber keine Ahnung,  wie oft der Zeiger
ausgeschaltet wurde.  Der Benutzer sollte nun selbst für eine Korrektur
des Problems sorgen.  Dies ist notwendig, wenn mit Anwendungen gearbei-
tet wird, die den Mauszeiger verwenden. Es kann sonst passieren, daß in
einem solchen Programm,  in dem die Maus gebraucht wird (z.B.  ein GEM-
Editor),  keine  auftaucht.  Es macht nicht viel Spaß,  jetzt  wie  ein
blindes  Huhn herumzuirren,  bis man wieder aus dem Programm  rauskommt
(wenn man nicht lieber gleich RESET drückt).
Man  sollte  also,  falls das angesprochene  Problem  aufgetaucht  ist,
solange  den Mauszeiger anschalten (mouseon),  bis er  wieder  sichtbar
ist.  Dann  gibt  man einmal mouseoff ein und die Welt  ist  wieder  in
Ordnung.  Normalerweise reicht es übrigens zweimal mouseon  einzugeben.
Der Aufwand bleibt also in einem vertretbaren Rahmen.


-> mouseon
Dieser Befehl schaltet den Mauszeiger ein.

-> mv <fileA> <fileB>
(kompletter Name: move)
Zum Umbenennen eines Files wird dieses Kommando zur Verfügung gestellt.
Aus 'fileA ' wird 'fileB'.
mv  kann  mit '*' benutzt werden.  Man sollte  allerdings  ein  bißchen
aufpassen, da die Möglichkeiten zum Unsinn anstellen nicht zu verachten
sind.
BEISPIEL:

                       mv oldie.dat uroldie.dat

Der File 'oldie.dat' wird in den File 'uroldie.dat' umbenannt.

-> numbers
Schaltet  ein  Flag  ein/aus,  das  bestimmt,  ob  bei  einem  Ausdruck
Zeilennummern ausgegeben werden.
flags kann zur Überprüfung der aktuellen Einstellung benutzt werden.

-> od <file(s)>
(kompletter Name: out dump)
Möchte  sich der Benutzer bestimmte Dateien in  hexadezimaler  Schreib-
weise anschauen, so kann er dies mit Hilfe dieses Kommandos tun.
Der/die File(s) werden seitenweise auf dem Bildschirm  ausgegeben.  Ein
Abbruch kann durch Drücken von ^Z erfolgen.                                    -21-


Der  Befehl  ist  so ausgelegt,  daß auch  auf  andere  Laufwerke  bzw.
Unterverzeichnisse zugegriffen werden kann.
BEISPIEL:

                            od command.txt

Gibt die Datei 'command.txt' hexadezimal aus.

                        od /megamax/headers/*.h

Hexadezimale  Ausgabe  aller  '.h'-Dateien  die  sich  im   Verzeichnis
'/megamax/headers/' befinden.

-> page [intvalue]
Ist  diese  Funktion  eingeschaltet,  wird am  Seitenanfang  bei  einem
Ausdruck  der Filename und die aktuelle  Seitennummer  ausgegeben.  Das
Argument gibt die Startseitennummer an.  Bei fehlendem Argument ist die
Funktion ausgeschaltet.

-> path <pfad(e)>
Angabe  eines  Pfades,  der zum Auffinden eines  Programmes  durchsucht
werden soll. Es können maximal zwanzig Pfade angegeben werden.
Programmnamen  müssen,  falls  sie nicht im  aktuellen  Verzeichnis  zu
finden  sind,  komplett angegeben werden!  Pfadnamen müssen  durch  '/'
(bzw. '\') abgegrenzt sein. Dies gilt allerdings auch, wenn es sich nur
um  Laufwerksnamen  handelt  (z.B.  "path a:/  c:/"),  dann  wird  dort
allerdings nur im Hauptverzeichnis gesucht.
In  vorhergehenden  Programmversionen erfolgte kein Sprung  in  die  zu
durchsuchenden Ordner.  Dieses Manko habe ich nun beseitigt.  Dies gilt
allerdings  nur  für Programme mit der  Extension  '.PRG'!  Ich  sollte
vielleicht den Grund für diese Einschränkung nennen:
Ich benutze einen bestimmten Ordner zur Aufbewahrung von  Tool-Program-
men,  die  mehr oder weniger die Endungen '.TTP' haben.  Nehme ich  nun
diesen  Ordner  in  die zu durchsuchenden  Pfade  auf,  wird  zwar  bei
Auffinden  des Programms in den Ordner gesprungen,  aber die  Argumente
(in der Hauptsache Files) befinden sich halt nicht dort,  also funktio-
niert  das  ganze nicht.  Da die meisten  Benutzer  GEM-Anwendungen  am
laufen  haben,  die  z.B.  'RSC'-Dateien nachladen und die  die  Endung
'.PRG' besitzen, dürfte man mit der Einschränkung leben können.
Selbstverständlich  kann dieser automatische Sprung in den zu  durchsu-
chenden Ordner auch abgeschaltet werden (vgl.  pchange).  Das  Kommando
verhält sich dann wie in den älteren Interpreterversionen.
Außerdem ist es jetzt auch möglich,  wie im Hauptverzeichnis,  nur noch
Teilstrings zum Starten eines Programmes einzugeben. Für die Eindeutig-
keit des Aufrufs muß allerdings der Benutzer selber sorgen!
Man  sollt  vielleicht auch noch beachten,  daß mit der Anzahl  der  zu                                     -22-


durchsuchenden Verzeichnisse auch die Zeit bis zur Auffindung bzw.  bis
zur Meldung, daß ein Programm nicht gefunden werden kann, steigt!
Die Suche nach einem Programm geschieht in folgender Reihenfolge:

     1. wenn ALIAS-Eintrag, dann Umwandlung
     2. wenn mit Pfadangabe, dann Ausführung
     3. wenn in aktuellem Verzeichnis, dann Ausführung
     4. die mit path festgelegten Wege absuchen und ggf. Ausführung
        es wird dabei die Argumentfolge in Reihe abgesucht!

Die Bedeutung von ALIAS wird in einem extra Abschnitt erläutert!
Da  ich  kein  rechtes  Vertrauen in  die  Fähigkeiten  des  TOS  habe,
existiert  beim  Wechseln der Pfade ein  Kontrollmechanismus,  der  bei
einem  fehlerhaften Ordneransprung eine Warnung  ausgibt.  Dies  sollte
eigentlich nie der Fall sein,  aber man soll nie nie sagen was das  TOS
betrifft.
BEISPIEL:

                    path /erste/ a:/ c:/oben/unten/

Ein externes Programm würde in diesem Fall erst im aktuellen  Verzeich-
nis gesucht werden.  Kann es dort nicht gefunden werden, wird versucht,
es  im Ordner '/erste/' zu finden.  Ist es auch dort  nicht  vorhanden,
wird zum Hauptverzeichnis auf Laufwerk A gegangen.  Bei einem  weiteren
Fehlschlag  wird  nun noch auf Laufwerk C im  Directory  '/oben/unten/'
gesucht.

                                 path

Ohne Argumente wird nur der eingestellte Suchpfad ausgegeben.

-> pchange
(kompletter Name: path change)
Schaltet den Pfadwechsel des path-Kommandos ein/aus. Mit flags kann die
aktuelle Stellung überprüft werden. Voreingestellt ist das Wechseln der
Directories.

-> pwd
(kompletter Name: print working directory)
Dieser  Befehl  zeigt den aktuellen Pfad an,  in dem  man  sich  gerade
befindet.

-> reset
Der Rechner führt einen Reset aus.

                                    -23-

-> resetlp [intvalue(s)]
(kompletter Name: reset lineprinter)
Dieser  Befehl  wurde bereits beim lp-Kommando  erwähnt.  Wird  lp  zum
Ausdruck  von  Dateien benutzt,  wird vor oder  nach  dem  eigentlichen
Druckvorgang eine Steuersequenz an den Drucker geschickt (z.B. Schrift-
größe oder ein Initialisierungskommando).
resetlp ist nun für die Sequenz zuständig, die nach dem Ausdruck an den
Drucker  geschickt wird.  Möchte der Benutzer,  daß keine solche  Folge
geschickt wird (Defaulteinstellung), muß er einfach resetlp eingeben.
Mit flags kann man sich die aktuell gültige Steuersequenz anschauen.
BEISPIEL:

                           resetlp 12 28 64

Diese  Sequenz  sorgt nach Abschluß eines Ausdrucks für  einen  Seiten-
vorschub  und  der Umschaltung auf die Grundeinstellung  eines  NEC-P6-
Druckers.

-> rm <file(s)>
(kompletter Name: remove)
Zum  Löschen  von Dateien findet dieser Befehl  Verwendung.  Es  können
damit  sowohl  ganze Filegruppen als auch nur  bestimmte  Einzeldateien
entfernt werden (Verwendung von Wildcarts ist möglich).
Man  sollte bei Benutzung des Kommandos ein  bißchen  aufpassen,  sonst
löscht man Dateien, die man eigentlich noch braucht.
Dieser  Befehl erlaubt den Zugriff auf andere Verzeichnisse  und  Lauf-
werke.
Es kann vorkommen,  daß Files vor dem Löschen geschützt sind (Attribut:
nur  lesbar).  Der  Befehl ist nicht in der  Lage,  solche  Dateien  zu
entfernen (vgl. auch save und unsave)!
BEISPIEL:

                                rm *.*

Hier werden alle Files gelöscht.

                         rm *.prg command.txt

Hier werden erst alle PRG-Dateien entfernt,  im Anschluß daran der File
'command.txt'.

                          rm c:/copy/c_files/

Auf Laufwerk C werden alle Dateien im Unterverzeichnis '/copy/c_files/'
gelöscht.
                                    -24-


-> rmdir <dirname>
(kompletter Name: remove directory)
Es  kann vorkommen,  daß Ordner entfernt werden sollen.  Der  geeignete
Befehl  findet sich in rmdir.  Der zu löschende Ordner  muß  allerdings
leer sein!
BEISPIEL:

                             rmdir schrott

Diese Eingabe bewirkt ein Entfernen von Directory 'schrott'.

-> save <file(s)>
Files,  auf  die dieser Befehl angewandt wird,  sind nur  noch  lesbar.
Rückgängig gemacht werden kann dieses Kommando mit unsave.
Man  sollte  beachten,  daß es Programme  gibt,  die  auf  solchermaßen
geschützte Dateien mit dem frohen Werfen von Bomben reagieren.  Es  muß
also vor Verwendung solcher Programme unsave benutzt werden!

-> savehist
(kompletter Name: save history)
Per  Defaulteinstellung wird beim Verlassen des Interpreters  ein  File
history.dat  angelegt,  in  dem  sich die  zuletzt  gemachten  Eingaben
befinden.
Dieser  Befehl bewirkt nun ein Ein-/Ausschalten dieser  Abspeicherfunk-
tion.
Mit  flags kann bestimmt werden,  ob sie gerade eingeschaltet  ist  und
kann dann,  je nach Benutzerwunsch,  umgeschaltet werden  (toggle-Funk-
tion).

-> setlp [intvalue(s)]
(kompletter Name: set lineprinter)
Die analoge Funktion zu resetlp findet sich in diesem Befehl.  Die hier
angebbare  Steuersequenz  wird  vor dem eigentlichen  Ausdruck  an  den
Drucker geschickt.  Soll nichts geschickt werden (default), ist einfach
wieder setlp einzugeben.
Mit flags kann die gültige Steuersequenz angeschaut werden.

-> settab <intvalue>
(kompletter Name: set tabulator)
Eine  weitere Funktion,  die den Ausdruck steuert,  wird  durch  dieses
Kommando abgedeckt.  Der Benutzer ist hiermit in der Lage,  die Tabula-
torweite zu bestimmen (defaultmäßig auf 8 Zeichen).  Die minimale Weite
liegt bei zwei Zeichen!
settab beeinflußt übrigens nicht nur Druckerausgaben. Auch Ausgaben via
cat oder more benutzen die eingestellte Tabulatorweite!
Dieser Befehl hat bei Listings natürlich nur eine Bedeutung,  wenn  das                                     -25-


Tabulatorflag,  daß angibt ob TAB oder die entsprechende Anzahl  Blamks
gesendet wird, gesetzt ist.
flags zeigt die aktuelle Tabulatorweite an.

-> slash
Normalerweise kann man statt '\' auch '/' benutzen (z.B.  bei  cd).  Es
gibt  aber  externe  Programme,  die mit  Argumenten  gefüttert  werden
können,  die  ein  '/' enthalten.  Da der Interpreter '/'  in  ein  '\'
umwandelt,  kann  es  hier zu Problemen kommen.  Mit slash  kann  diese
Konvertierung ein- bzw. ausgeschaltet werden.
Mit flags kann der aktuelle Zustand angeschaut werden.

-> srhist
(kompletter Name: set/reset history)
Normalerweise  werden die letzten fünfzig Eingaben in einer  Historyta-
belle gehalten. Damit ist der Benutzer in der Lage, auf einfache Weise,
auf diese Kommandos Bezug zu nehmen (s.u.).
Um  diese Eintragungen ein-/auszuschalten,  kann dieser Befehl  benutzt
werden.
Mit  flags kann der aktuelle Stand des entsprechenden Flags  angeschaut
werden. srhist erzeugt dann die entgegengesetzte Stellung.
Finden  keine Eintragungen in die Historytabelle statt,  erscheint  der
Eingabezähler invers.

-> srtab
(kompletter Name: reset tabulator)
Normalerweise  (default) sendet der Befehl lp keine TAB-Zeichen an  den
Drucker,  sondern  expandiert  diese Zeichen korrekt  und  schickt  die
entsprechende   Anzahl  Blanks.   Dieser  Befehl  kann  nun  zum   Set-
zen/Rücksetzen dieser Fähigkeit benutzt werden.
Mit flags kann die aktuelle Einstellung überprüft werden.

-> srtitle
(kompletter Name: set/reset title)
Nun zum vorletzten Befehl, mit dem ein Druckerlisting beeinflußt werden
kann.  Defaultmäßig wird vor jedem Ausdruck ein Titelblatt erzeugt, auf
dem  der Filenamen steht.  Ist dies jedoch nicht  gewünscht,  kann  mit
srtitle diese Möglichkeit abgeschaltet (oder auch wieder eingeschaltet)
werden.
Mit flags kann mal wieder der aktuelle Zustand des entsprechenden Flags
angeschaut werden.

-> string  <filedescriptor> <string>
Dieser  Befehl  dient dem Absuchen von Dateien  nach  einer  bestimmten
Zeichenfolge.  Es  kann  dabei sowohl nur eine Datei als  auch  mehrere
angesprochen  werden  (über  '*').  Der Suchstring  muß  zwischen  zwei                                     -26-


gleiche Zeichen eingeschlossen sein!  Der Befehl bezieht sich immer auf
das aktuelle Verzeichnis.
Die  maximale  Länge  eines solchen Strings  beträgt  zwanzig  Zeichen.
Überschreitet er diese, erfolgt eine Kürzung auf diese Zeichenlänge!
BEISPIEL:

                       string  *.* /Oh sole mio/

Es  werden alle Dateien des aktuellen Ordners nach dem String 'Oh  sole
mio'  abgesucht.  Wird  der String in einem File  gefunden,  wird  eine
entsprechende Meldung ausgegeben.

                      string  command.txt *Bingo*

In  diesem  Fall wird der File 'command.txt' nach  dem  String  'Bingo'
abgeklappert.
Man sieht, daß die Argumentbegrenzungen völlig verschieden sein können,
im  oberen  Beispiel  '/',  im unteren '*'.  Sie  müssen  nur  bei  der
jeweiligen  Eingabe übereinstimmen.  Es versteht sich wohl von  selbst,
daß diese Begrenzungen nicht im eigentlichen Suchstring enthalten  sein
dürfen!

-> sz
Der  letzte  Befehl zur Druckersteuerung.  Er entstand aus  dem  Mangel
meines Druckers, ein vernünftiges 'ß' machen zu können.
Ist das entsprechende Flag gesetzt,  wird einfach der Code für ein Beta
(225)  geschickt,  wenn im Text ein 'ß' vorkommt.  Ist das  Flag  nicht
gesetzt, wird der eigentliche 'ß'-Code geschickt (158).
Mit  flags  kann die Flagstellung überprüft  werden.  Defaultmäßig  ist
dieses Flag übrigens gesetzt, also wird Beta geschickt!

-> time [hh:mm]
Das Setzen bzw. Abfragen der Uhrzeit geschieht mit diesem Kommando.
Wird  kein Argument angegeben,  so erfolgt eine Ausgabe  der  aktuellen
Systemzeit, sonst wird das Argument als neue Systemzeit übernommen. Bei
der  Ausgabe  werden auch die Sekunden angegeben.  Beim  Setzen  dürfen
diese nicht angegeben werden!
BEISPIEL:

                               time 12:4

Setzen  der Uhrzeit auf 12 Uhr 4 Minuten.  Die Sekunden werden  automa-
tisch auf Null gesetzt.

-> tree
Ausgabe aller Ordner und Unterordner eines Laufwerks.                                    -27-



-> unsave <file(s)>
Files,  die nur lesbar sind,  also nicht gelöscht werden können, werden
durch dieses Kommando entschützt. Der umgekehrte Befehl ist save.

-> version
Dieses  Kommando  gibt das Erstellungsdatum  aus.  Es  existiert  keine
Versionsnummer mehr!

-> wc <file(s)>
(kompletter Name: word count)
Interessiert  man sich für die Anzahl von Ziffern,  Zeilen und  Zeichen
eines Files,  so findet dieser Befehl Verwendung.  Alles in allem  kein
besonders wichtiges Kommando.


3.1 Besondere Befehle

Die  folgenden vier Befehle die zum Erzeugen eines ASCII-Files  benutzt
werden konnten, gibt es nicht mehr:

                            open <file>
                            write <string>
                            append <file>
                            close

Dies stellt allerdings keine Einschränkung bei der einfachen  Kreierung
von  Textdateien dar.  Ich möchte den Benutzer auf den  Abschnitt,  der
sich mit der Ausgabeumleitung befaßt,  verweisen. Die Verbindung dieser
Möglichkeit  mit  dem echo-Befehl erlaubt sämtliche Aktionen  der  vier
weggefallenen Befehle.
Der Grund für das Streichen der Kommandos war wieder der  Versuch,  den
Interpreter etwas kompakter zu machen und redundante Befehle,  die  nur
einen  unnötigen Ballast darstellen,  zu  entfernen.  Ich  glaube,  daß
zumindest  in diesem Fall keine Einschränkung für den Benutzer  gegeben
ist.


Möchte der Benutzer das Laufwerk wechseln,  kann er dazu den  cd-Befehl
benutzen, dies ist aber nicht unbedingt notwendig. Es ist auch möglich,
diesen  Wechsel einfach durch Laufwerkskennung und anschließenden  Dop-
pelpunkt vorzunehmen.
BEISPIEL:
                                  a:

Wechsel zu Laufwerk A.                                    -28-




3.2 Zahlkonvertierungen

Es kommt ab und zu vor, daß Zahlumrechnungen vorgenommen werden müssen.
Der Interpreter stellt hier drei Funktionen zur Verfügung:

-> #<decvalue>
Eingabe einer Dezimalzahl und deren Umrechnung in das hexadezimale  und
oktale Äquivalent.

-> $<hexvalue>
Eingabe einer hexadezimalen Zahl. Als Resultat werden die dezimalen und
oktalen Äquivalente ausgegeben.

-> \<octvalue>
Und  als  letztes  die Umrechnung für  oktale  Zahlen.  Man  kann  hier
übrigens ein Problem erkennen, daß eventuell auftritt, wenn mit '\' ein
Programm  aufgerufen werden soll.  Im Zweifelsfall muß man einfach  nur
die Laufwerksbezeichnung mit angegeben oder mit '/' arbeiten.


                                    -29-

4 Die ALIAS-Einrichtung

4.1 Einführung

Der Kommandointerpreter bietet dem Benutzer die Möglichkeit,  bestimmte
Befehle umzubenennen.  Wird zum Beispiel öfters ein spezielles Programm
aufgerufen, kann dieser Aufruf umbenannt werden.
Sei das Programm 'xcompiler.prg' immer wieder aufzurufen,  kann  dieses
Kommando  z.B.  in  'cc' umbenannt werden (sinnigerweise  gehe  ich  in
diesem  Beispiel  davon  aus,  daß dieser ominöse  'xcompiler'  ein  C-
Compiler ist.  'cc' wäre sonst ein recht verwirrender Name).  Wird  ein
Editor  öfters  zum Editieren eines bestimmten  Files  aufgerufen  (bei
einer  Programmerstellung passiert dies eigentlich dauernd),  kann  der
normale  Aufruf  'editor.prg  file' einfach  in  einen  kürzeren,  z.B.
'edit', umbenannt werden.
Schreibfaule Naturen und Leute,  die mit der Namensgebung der  internen
Kommandos nicht besonders glücklich sind, können durch diesen Mechanis-
mus ihre eigene Nomenklatur aufbauen.

Sämtliche Umbenennungen können im File alias.dat abgelegt werden. Diese
Datei  wird  zum  Programmbeginn  von  command.prg  eingelesen  (soweit
vorhanden natürlich). Dies funktioniert allerdings nur, wenn sich diese
Datei im gleichen Verzeichnis wie der Interpreter befindet!
alias.dat  wird übrigens beim Verlassen von command.prg  nicht  automa-
tisch abgespeichert (vgl. savealias).
Die  alternativen Kommandonamen können also sofort genutzt  werden  und
müssen nicht zu jeder Sitzung neu eingegeben werden!
Es  ist  natürlich  möglich ganz ohne  alias.dat  auszukommen  und  die
Erzeugung  der  Umbenennungen durch einen  Batchfile  vorzunehmen.  Der
bequemere Weg erscheint mit jedoch die Verwendung dieser Datei zu sein.

4.2 ALIAS-Befehlssatz

-> alias [string(s)]
Aufzeigen  aller aktuell gültigen Umbenennungen und ihrer  Äquivalente.
Es  ist  auch  die selektive Auswahl  eines  Eintrags  (bzw.  mehrerer)
möglich.

-> delalias <name>
(kompletter Name: delete alias)
Löschen eines Alias-Eintrags aus der Alias-Liste.

-> getalias
Der File alias.dat wird mit diesem Kommando eingelesen.

                                    -30-

-> newalias <new> <old>
Umbenennung  von 'old' in 'new'.  Dieser Befehl dient also  zur  Alias-
Erzeugung.
Neue  Einträge  werden  übrigens nicht an  die  Alias-Liste  angehängt,
sondern stehen immer an erster Stelle (Zeit- und Codeersparnis).
BEISPIEL:

                       newalias cc xcompiler.prg

Die  Beschreibung  steht eigentlich schon in dem  obigen  Blabla.  Jede
Eingabe von 'cc' wird duch 'xcompiler.prg' ersetzt.

                           newalias al alias

Statt alias führt nun auch al zum Aufzeigen der Alias-Einträge.

-> savealias
Abspeichern  der  gültigen  Umbenennungen im  File  alias.dat.  Es  muß
beachtet  werden,  daß  dieses  Ablegen  der  Datei  nicht  automatisch
erfolgt!
Man  kann  sich  übrigens mithilfe eines  Batchfiles  eine  Enderoutine
schreiben,  die  man  zum Verlassen des Interpreters  aufruft  und  die
savealias enthält.


                                    -31-

5 Die History-Einrichtung

5.1 Einführung

Ein  weiteres  Bonbon des Interpreters  ist  die  Möglichkeit,  bereits
eingegebene  Befehle  auf einfache Weise erneut  aufzurufen.  Dies  ist
allerdings auf die letzten fünfzig Eingaben beschränkt.
UNIX-Kennern dürfte diese Einrichtung und ihre Vorzüge wohl hinlänglich
bekannt sein.
Ein  einfaches Beispiel soll die praktische Anwendung dieser  Fähigkeit
aufzeigen. Zum Erstellen eines Programms in C, PASCAL u.s.w. sind immer
die gleichen Schritte notwendig:

            Editieren -> Compilieren -> Linken -> Probelauf

Meist erfolgt zwischen Compilieren und Linken noch eine Kurzvisite beim
Editor,  weil  halt  doch  noch ein kleines  Fehlerchen  im  Sourcecode
aufgetaucht ist.

Die Kommandos für das Beispiel seien nun folgende:

77>ed bsp.pas

Bedeutung: Aufruf des Editors zur Bearbeitung des Files 'bsp.pas'.

78>pas bsp.pas

Bedeutung: Aufruf des Compilers zur Objektfileerzeugung.

Sollten  jetzt Fehlermeldungen aufgetaucht sein,  geht's wieder  zurück
zum Editor. Also wieder

79>ed bsp.pas

reinklopfen u.s.w.

Bevor  es jetzt weitergeht,  sollte ich vielleicht  verraten,  daß  die
Zahlen vor den Beispieleingaben vom Interpreter geliefert werden.
Dieser  kleine Hinweis ist für das weitere Verständnis  ziemlich  hilf-
reich!

Durch die Historyeinrichtung genügt es, wenn der Benutzer bei Befehl 79
("ed  bsp.pas")  einfach nur "!77" eingibt.  Es wird dann  Kommando  77
erneut ausgeführt.
Es  kann  aber nicht nur über die  Kommandonummern  auf  zurückliegende
Eingaben  Bezug  genommen  werden;  die Eingabe  "!e"  hätte  auch  zum                                     -32-


Wiederaufruf des Editors geführt,  d.h. es wird bei dieser Eingabe nach
dem letzten Kommando gesucht,  daß mit dem Buchstaben 'e' begonnen hat,
und, falls es gefunden werden kann, erfolgt ein erneuter Aufruf des nun
expandierten Befehls (hier wäre dies "ed bsp.pas").

Die Möglichkeit,  alte Kommandos über den Anfangsbuchstaben zurückzuho-
len,  ist nicht auf einen Buchstaben begrenzt. Es wird nach dem letzten
Kommando  gesucht,  daß mit dem eingegebenen Teilstring  übereinstimmt.
Ein weiteres Beispiel soll das verdeutlichen: Hat der Benutzer kürzlich
den  Befehl "cp afile bfile" eingegeben und auf diesen  Befehl  folgend
das  Kommando  "cmp afile bfile",  so würde durch "!c"  der  cmp-Befehl
erneut  aufgerufen  werden.  Durch  Eingabe von "!cp"  würde  aber  ein
eindeutiger Bezug auf den Kopierbefehl geschaffen und dieser ausgeführt
werden.
Es  ist  also möglich,  durch beliebig  lange  Teileingaben  eindeutige
Zuordnungen  zu vorhergehenden Befehlen zu bilden.  Es sei noch  einmal
darauf  hingewiesen,  daß  sich in der History-Liste  nur  die  letzten
fünfzig  Befehle  befinden  und  daß man nur  diese  erneut  durch  die
History-Kommandos aufrufen kann.
Jede Neueingabe wird in diese Liste eingetragen, dafür wird der älteste
Eintrag  entfernt.  Normalerweise müßte aber der Umfang  der  gemerkten
Kommandos mehr als ausreichend sein.
Das bisher gesagte möchte ich mit einem Beispiel noch etwas  anschauli-
cher machen:

120>cp afile bfile
121>cmp afile bfile
122>!c
123>!cp
124>!121

Es werden wieder cp und cmp verwendet. Die Kommandos 120 und 121 müßten
eigentlich klar sein.  Kommando 122 ruft das letzte Kommando  auf,  daß
mit  dem Buchstaben 'c' begann auf,  in diesem Fall cmp.  Kommando  123
ruft den letzten Befehl auf,  der mit den Buchstaben 'cp' beginnt,  und
das  ist  Kommando 120.  Befehl 124 bezieht sich nun explizit  auf  ein
Kommando, den cmp-Befehl.

Zusätzlich  zu den !-Kommandos gibt es noch eine  weitere  Möglichkeit,
auf alte Eingaben zugreifen zu können:
Wer  schon  auf  einer VAX unter VMS gearbeitet  hat,  dürfte  mit  der
Verwendung der CURSOR-UP bzw. CURSOR-DOWN-Tasten in diesem Zusammenhang
vertraut  sein.  Auch  dieser Interpreter erlaubt es mit  Hilfe  dieser
Tasten,  alte  Befehle  wieder  sichtbar zu  machen.  Es  ist  außerdem
möglich,  durch  Verwendung der Cursortasten und der bereits am  Anfang
erwähnten Tasten, diese alten Kommandos frei zu editieren.                                    -33-


Vorhergehende  Befehle werden mit der CURSOR-UP-Taste  aufgerufen,  ein
Zurückblättern wird durch die CURSOR-DOWN-Taste bewerkstelligt.


5.2 Die !-Befehle

-> h
(kompletter Name: history)
Dieser Befehl gibt alle in der History-Liste stehenden Einträge auf den
Bildschirm aus (die Eingabe von history bewirkt das gleiche).

-> !<nr>
Hier wird das Kommando mit der Nummer 'nr' noch einmal aufgerufen.
In  Verbindung  mit der folgenden Historyfunktion  '!<string>'  muß  an
dieser  Stelle leider auf einen Schwachpunkt hingewiesen  werden!  Pro-
gramme,  die  mit  einem  Ziffernstring  beginnen  und  die  nun  durch
'!<ziffernstring>'  erneut aufgerufen werden sollen,  kommen nicht  zur
Ausführung (bzw.  nur dann,  wenn zufälligerweise der Ziffernstring mit
der Kommandonummer übereinstimmt),  d.h.  Zahlen die sich auf Kommando-
zeilen beziehen, haben immer Vorrang vor anderen Strings! Das soll aber
nicht  heißen,  daß  es unmöglich  ist,  solche  speziellen  'Ziffern'-
Eingaben  zu wiederholen.  Nur muß man dann statt einem  Ausrufezeichen
zwei verwenden! Ein Beispiel soll diese Problematik etwas beleuchten:

                               101>1.prg
                               102>!!1
                               103>!1

Kommando  101  ruft ein Programm '1.prg'  auf,  102  wiederholt  diesen
Aufruf.  Nummer 103 führt zu einer Fehlermeldung, da der Befehl mit der
Nummer 1 nicht mehr in der Historytabelle vorhanden ist.

-> !<string>
Es soll das letzte Kommando gestartet werden, daß mit 'string' beginnt.
Man  beachte die beim vorhergenden Kommando  angesprochene  Restriktion
dieses Befehls!

-> !!
Die letzte Eingabe wird wiederholt.
Ältere Versionen des Kommandointerpreters erlaubten statt zwei Ausrufe-
zeichen  auch  die Verwendung von nur einem.  Dies führt nun  zu  einer
Fehlermeldung!


                                    -34-

6 Das Batch-Processing

6.1 Einführung

Ich will nun auf die nächste Fähigkeit des Interpreters  eingehen,  die
Abarbeitung von Batchdateien.
Leider  wird  diese Möglichkeit auch auf Systemen,  die  dafür  bereits
'serienmäßig'  eingerichtet sind,  zu selten genutzt.  Lieber gibt  ein
Benutzer immer wieder die gleiche Befehlsfolge ein, als sich eine Datei
zu  erstellen,  die diese Folge enthält und die einfach nur  aufgerufen
werden muß.
In  einer  Batchdatei kann prinzipiell jedes  der  bisher  besprochenen
Kommandos stehen.  Es gibt noch eine ganze Reihe weiterer Befehle,  die
den Ablauf innerhalb eines solchen Files steuern (z.B. Sprungmarken).

Wird in einem Batchfile viel gesprungen,  bzw.  finden  Schleifendurch-
läufe statt,  sollte der File in einer RAM-Disk abgelegt und  gestartet
werden.  Das  bringt zum einen einen gewissen Zeitgewinn und nutzt  auf
der  anderen  Seite  die Diskette nicht so  ab.  Ich  möchte  es  nicht
unerwähnt  lassen,  daß der Interpreter den Batchfile nicht auf  einmal
einliest  und  dann abarbeitet,  sondern Kommando  für  Kommando  holt.
Dadurch  wird etwas Speicher gespart und die Verwaltung ist um  einiges
einfacher.

Die  Abarbeitung einer Batchdatei kann jederzeit durch  ^Z  abgebrochen
werden!

Befehle eines Batchfiles werden nicht in die History-Liste aufgenommen!

Die  im  Folgenden  beschriebenen  Befehle  können  zum  Teil  auch  im
Direktmodus eingegeben werden,  dies ist allerdings bei einigen Komman-
dos nicht sehr sinnvoll.

Wichtige Änderung:
In  den  älteren Versionen des Interpreters gab es  die  festeingebaute
Variable  counter.  Seit Einführung der Variablen,  ist diese und  alle
ihre  Funktionen nicht mehr notwendig.  Um den Programmcode zu  kürzen,
habe  ich  deshalb  diese  Variable  entfernt.  Benutzer  von  counter-
Befehlen, müssen diese durch entsprechende Variablenkommandos ersetzen!


6.2 Befehlssatz

-> batch <file> [arg0...arg9]
Aufruf einer Batchdatei 'file'.  'arg0' bis 'arg9' entsprechen Strings.
Innerhalb eines Batchfiles können Platzhalter gesetzt werden ('$0'  bis                                     -35-


'$9').  Diese  werden durch die Strings ('arg0' bis 'arg9')  bei  einem
Abarbeiten des Batchfiles ersetzt. Dadurch wird erreicht, daß z.B. eine
Batchdatei,  die  die  Compilierung und das  Linken  eines  Sourcefiles
zusammenfaßt, für unterschiedliche Sourcefiles Verwendung finden kann.
Die  Argumente  müssen aufsteigend bei 0 beginnend  eingesetzt  werden,
d.h. jedes '$0' wird durch das erste Stringargument ersetzt, jedes '$9'
würde durch jedes neunte Stringargument ersetzt werden.  Es stehen also
maximal zehn solche Platzhalter zur Verfügung.
Weiter unten folgen einige Beispiele,  die unter anderem die Verwendung
dieser Argumentersetzung beleuchten sollen.
Für faule Benutzer gibt es die Möglichkeit, auf die Extension '.COM' zu
verzichten,  auch wenn die Batchdatei diese besitzen sollte.  Kann  der
Interpreter einen angegebenen Batchfile nicht finden,  versucht er noch
durch  Anhängen von '.COM' zum Erfolg zu kommen.  Beispielsweise  würde
die  Datei  'BSP.COM'  durch  "batch bsp"  und  durch  "batch  bsp.com"
aufgerufen  werden.  Ich  möchte  an dieser  Stelle  betonen,  daß  ein
Batchfile  durchaus keine Extension haben muß.  Jeder gültige  Filename
kann für eine Batchdatei verwendet werden!
Es können maximal 3 Batchfiles zur gleichen Zeit laufen (sich gegensei-
tig  aufrufen)!  Die  Argumente  sind in jedem  dieser  drei  möglichen
Dateien unterschiedlich,  d.h.  besitzt File A die Belegung  'BEISPIEL'
für  '$0' und ruft dann File B auf,  so ist dort '$0'  unbesetzt,  wenn
beim Aufruf kein Argument explizit angegeben worden ist.

Das  mit  den  Argumenten möchte ich an dieser  Stelle  noch  an  einem
kleinen Beispiel zu verdeutlichen versuchen.
Ich  gehe  mal davon aus,  daß man sich in  command.prg  befindet.  Die
folgende  Eingabesequenz  erzeugt nun eine  Batchdatei  'BSP.COM',  die
nichts  anderes  macht,  als zwei Argumente mit  echo  auszugeben.  Der
Benutzer kann daran die Wirkung der $-Ersetzung durch  Eingabeparameter
erkennen (hoffentlich).

                         80>echo|bsp.com
                         81>echo||bsp.com echo $0 $1
                         82>batch bsp.com arg1 arg2
                          arg1 arg2
                         83>

Je  nachdem  mit welchen Argumenten diese Datei  nun  aufgerufen  wird,
ändert  sich  die Ausgabe.  Man sollte sich ruhig auch  mal  anschauen,
welche Ausgabe bei fehlender Argumentangabe kommt bzw.  bei Angabe  von
drei oder noch mehr Parametern.

-> @<file> [arg0 ... arg9]
Analog zu batch, nur diesmal mit @. Dieses Kommando ist einfach nur für
die Liebhaber von VMS gedacht.                                    -36-



-> ?arg <argument nummer> <label>
Wurde  ein  Batchfile mit dem Argument versorgt,  so  wird  zu  'label'
gesprungen  (eine  '$0'-Überprüfung wird z.B.  durch  "?arg  0  ist_da"
repräsentiert).

-> ?batch
Gibt die Anzahl der gerade laufenden Batchdateien aus.  Es können,  wie
bereits  angesprochen,  maximal  drei Batchdateien  gleichzeitig  offen
sein.

-> restart
Befehl  innerhalb  einer Batchdatei zum Neustart der  Datei,  also  die
ganze Chose wieder von vorne, d.h. Sprung zur ersten Befehlszeile.

-> wait
Warten  auf das Drücken einer Taste.  Die Abarbeitung eines  Batchfiles
wird solange angehalten, bis eine Taste gedrückt wird.
Wird an dieser Stelle ^Z gedrückt,  erfolgt ein Abbruch der  Batchbear-
beitung!
Dieses Kommando kann z.B.  dazu verwendet werden, die Abarbeitung eines
Batchfiles solange anzuhalten bis ein ausgegebener Text gelesen  worden
ist.

-> stop
Stoppen eines Batchfiles.

-> ?stop
Bedingtes Stoppen einer Batchdatei.  Der Benutzer wird gefragt,  ob der
Batchfile  angehalten  werden  soll (die  voreingestellte  Antwort  ist
übrigens nein).

-> break
Es  werden  sämtliche laufenden Batchfiles  gestoppt,  d.h.  ruft  eine
Batchdatei  eine andere auf,  in der dann dieser Befehl  steht,  werden
beide Filebearbeitungen abgebrochen (im Gegensatz zu stop).

-> text
Jedes  Kommando  innerhalb  des  Batchfiles  soll  auf  dem  Bildschirm
angezeigt werden. Diese Einstellung ist default.
Mit flags kann die aktuelle Einstellung angeschaut werden.

-> notext
Die Umkehrung zu text.  Nach diesem Kommando werden die Batch-Dateikom-
mandos nicht mehr ausgegeben.
                                    -37-


-> errorbreak
Normalerweise wird eine Batchbearbeitung abgebrochen,  wenn ein  Fehler
auftritt.  Dies  kann durch errorbreak ein- bzw.  ausgeschaltet  werden
(abhängig  von  der gerade aktuellen Einstellung,  die  mit  flags  mal
wieder angeschaut werden kann).

-> lbl <marke>
(kompletter Name: label)
Einführung einer Sprungmarke in einem Batchfile.
Diese Marken können mit goto und einigen anderen Befehlen  angesprungen
werden.
Zum  Aufbau von Schleifen in Batchdateien muß mit diesen  Anprungmarken
gearbeitet werden.
In einer lbl-Zeile dürfen sonst keine Befehle stehen! Also wäre z.B.

                lbl beispiel echo dies ist ein Beispiel

nicht erlaubt (es kommen zwei Kommandos, lbl und echo, vor).

-> goto <marke>
Sprung zur angegebenen Marke (vgl. lbl).

-> exist <file> <marke>
Es  wird getestet,  ob die Datei 'file' existiert.  Ist dies der  Fall,
wird  zu  'marke'  gesprungen,  ansonsten  wird  beim  nächsten  Befehl
weitergemacht.
BEISPIEL:

                        exist test.prg paletti

Existiert der File 'test.prg' wird zur Marke 'paletti' gesprungen.

-> size0 <file> <marke>
Existiert  die Datei 'file' nicht oder ist ihre Größe  Null,  wird  zum
angegebenen  Label  'marke'  gesprungen,  ansonsten  auch  wieder  beim
Folgebefehl weitergemacht (die umgekehrte Funktion von exist).

Die  Kommandos  size0 und exist sind ganz praktisch,  wenn  es  um  die
Compilierung/Assemblierung  und Linkung von Sourcefiles geht.  Es  gibt
z.B. Compiler, die auf das Fehlen eines Sourcefiles mit einem Bombenha-
gel reagieren. Dieses Problem kann mit diesen Befehlen umgangen werden.

-> ; [Kommentar]
Durch  ;  werden Kommentarzeilen eingeleitet,  die  keinerlei  Befehls-
funktion  haben  und  nur zum  besseren  Verständnis  einer  Batchdatei
beitragen sollen.                                    -38-


;  kann übrigens auch nach einem Befehl stehen, alles vor dem Semikolon
wird ausgeführt, alles danach wird ignoriert.
Dieses  markieren von Kommentarbereichen funktioniert nur  in  Batchda-
teien,  wird im Direktmodus versucht eine Kommentarzeile einzugeben, so
wird  diese wie eine normale Zeile aufgefaßt,  d.h.  es dürfte wohl  zu
einer Fehlermeldung kommen.

-> status
Ausgabe einer Variablen,  die zur Steuerung innerhalb eines  Batchfiles
benutzt  wird.  Sie  wird vor jedem Ablauf einer  Batchdatei  auf  Null
gesetzt.
Werden innerhalb des Files andere Programme (z.B.  Compiler) gestartet,
so  wird  deren  Rückgabewert  in  status  abgelegt.  Ein  fehlerhafter
Compilerlauf  kann also zum Sprung zu einer bestimmten Marke  oder  zum
Ausstieg  aus  dem Batchfile führen.  Der Benutzer muß  allerdings  die
Rückgabewerte der Programme und ihre Bedeutung kennen.
Es  kommt  diesem Systemparameter aber noch eine andere  Bedeutung  zu.
Jede  Fehlermeldung  des Interpreters hat in  einer  Fehlernummer,  die
diese Variable dann enthält,  ihren Niederschlag.  Damit lassen sich in
Batchdateien  bestimmte  Reaktionen auf eventuell  aufgetretene  Fehler
einbauen (in BASIC würde man wohl von ON ERROR GOTO sprechen).
Ich  möchte noch einmal hervorheben,  daß der Benutzer keinen  direkten
Einfluß  auf  die Belegung von status nehmen kann!  Sie wird  nur  beim
Start  eines  Batchfiles  auf Null  gesetzt,  bzw.  wenn  ein  externes
Programm  den  Rückgabewert  Null liefert.  Sollte  jemand  mit  dieser
Einschränkung  nicht  leben können,  muß er sich halt  einen  Batchfile
schreiben,  der nichts macht und diesen dann aufrufen; das Ergebnis ist
dann ein status-Wert Null.
Wird  nur  der  Befehl  status  eingegeben,  erfolgt  die  Ausgabe  des
Variablenwertes. Damit lassen sich also Rückgabewerte bestimmen.
status ist ein Longinteger (32-Bit).

-> oldy <fileA> <fileB> <label>
Wenn das Erstellungsdatum von 'fileA' vor dem von 'fileB'  liegt,  wird
zu 'label' gesprungen.
Mit diesem Befehl ist es möglich, eigene MAKE-Umgebungen zu erstellen.
Im  Anhang  befindet sich ein Beispiel,  daß sich  mit  der  Verwendung
dieses Befehls auseinandersetzt.

-> shiftarg
(kompletter Name: shift argument)
Verschiebt  existierende  Argumente um eine Position  nach  links.  Das
erste Element fällt dabei heraus.
Existieren  keine  Elemente,  hat dieses Kommando  keine  Funktion  (es
erfolgt keine Fehlermeldung)!
Existieren z.B.  die drei Argumente ARG1, ARG2 und ARG3, dann wäre ARG1                                     -39-


$0 zugeordnet, ARG2 $1 und ARG3 $2. shiftarg würde nun ARG1 löschen und
die  beiden verbleibenden Argumente um eins nach links  schieben,  d.h.
ARG2 wäre nun $0 zugeordnet und ARG3 $1. $2 besitzt kein Argument mehr.
Mit  diesem  Befehl kann in Batchdateien auf eine variable  Anzahl  von
Eingabeparametern eingegangen werden bzw.  die Erstellung von Schleifen
ist flexibler geworden.

-> setarg <argument(e)>
(kompletter Name: set argument)
Mit diesem Kommando lassen sich $-Parameter belegen.  Dabei wird  immer
der  erste  freie Parameter belegt.  Übersteigt die Anzahl  dabei  zehn
Parameter, werden die überzähligen Argumente ignoriert.
Währe $0 bereits mit String XYZ belegt (z.B. durch eine Parameterangabe
beim Aufruf des Batchfiles),  würde der Befehl "setarg abc" $1 mit  dem
String abc belegen.

-> inquire [string]
Dieser Befehl stellt das interaktive Äquivalent zu setarg dar.
Stößt  der Kommandinterpreter in einem Batchfile auf  dieses  Kommando,
muß der Benutzer ein oder mehere Argumente eingeben.  Diese werden dann
wie bei setarg  auf die $s verteilt.
'string' repräsentiert den Text,  der den Benutzer zur Eingabe  auffor-
dert. Diese Angabe ist optional.
BEISPIEL:
                         ?arg 0 gibt_argument
                         inquire Argument
                         lbl gibt_argument
                         echo $0

Diese Zeilen sollen einen Beispielbatchfile darstellen. Wird dieser mit
einem Argument aufgerufen erfolgt ein direkter Sprung zu  echo,  anson-
sten wird der Benutzer aufgefordert, ein Argument einzugeben.

-> cleararg
(kompletter Name: clear argument)
Löscht alle vorhandenen Parameterbelegungen für $-Argumente.

-> ifarg <string1> <string2> <label>
(kompletter Name: if argument)
Wenn 'string1' gleich 'string2' ist, wird zu 'label' gesprungen.
Dieser  Befehl ist hauptsächlich für die flexible Reaktion  auf  unter-
schiedliche Eingabeparameter in Batchdateien gedacht.

-> <> <intvalue>
Ist  status ungleich 'intvalue' (Integerzahl),  wird  der  Batchvorgang
abgebrochen (z.B. nach einem fehlerhaften Compilerdurchlauf).                                    -40-



-> < <intvalue>
Ist status kleiner als 'intvalue' wird der Batchfile abgebrochen.

-> > <intvalue>
Ist status größer als 'intvalue' wird der Batchfile abgebrochen.

-> == <intvalue>
Ist status gleich 'intvalue' wird der Batchfile abgebrochen.

-> ?status= <zahl> <label>
-> ?status# <zahl> <label>
-> ?status> <zahl> <label>
-> ?status< <zahl> <label>
Ist  status gleich,  ungleich,  größer oder kleiner als eine  bestimmte
'zahl' soll zur Marke 'label' gesprungen werden.
Damit  kann z.B.  nach einem fehlerhaften Compilerdurchgang  direkt  zu
einem Editoraufruf gesprungen werden.
Es gibt aber auch noch andere interessante Möglichkeiten. Gibt z.B. ein
bestimmtes Programm je nach internem Lauf bzw.  Resultat andere Parame-
ter  nach Programmende zurück,  kann mithilfe von status ein  Batchfile
aufgebaut werden, der auf diese unterschiedlichen Rückgaben individuell
reagiert  (z.B.  Steuerungsaufgaben lassen sich damit recht  problemlos
bewältigen).

Soweit  die etwas  spezielleren Batchfile-Kommandos,  die das  Arbeiten
mit diesen Dateien besonders unterstützen sollen.

Befindet  sich  im Verzeichnis,  das  command.prg  enthält,  die  Datei
auto.com,  so  werden  die  darin enthaltenen Befehle  beim  Start  des
Interpreters ausgeführt. Es lassen sich auf diese Weise z.B. Funktions-
tasten vorbelegen oder bestimmte Flags setzen.


                                    -41-

6.3 Beispiele

6.3.1 Bsp.1

     ;
     ; Batchfile zur Compilierung und zum Linken eines C-Files
     ; durch den MEGAMAX-C-Compiler
     ;
     mmcc.ttp $0.c            ;Aufruf des Compilers
     <> 0                     ;Abbruch, wenn Fehler aufgetreten ist
     mmlink.ttp $0.o -O $1    ;Aufruf des Linkers
     <> 0                     ;Abbruch im Fehlerfall
     rm $0.o                  ;Löschen des Objektfiles

Das  vorliegende  Beispiel kann direkt zur Arbeit  mit  dem  MEGAMAX-C-
Compiler (nicht LASER-C !) herangezogen werden (ggf.  muß man natürlich
noch Pfadnamen für das Compiler- und Linkerprogramm anfügen).

Die ersten vier Zeilen dienen lediglich der Kommentierung der  Batchda-
tei. In Zeile fünf wird der Compiler aufgerufen. '$0' repräsentiert den
Namen des Sourcefiles (Eingabe ohne Extension!).
Der  Compiler gibt bei einem erfolgreichen Durchlauf eine Null  zurück.
Andernfalls sorgt Zeile sechs für einen Abbruch der Batchbearbeitung.
Nach  der  Compilierung soll der Objektfile gelinkt  werden.  Dies  ge-
schieht  in  Zeile  sieben.  Sollten dort  Probleme  aufgetreten  sein,
erfolgt in Zeile acht ein Abbruch.
In  Zeile  neun wird der aufgetretene Objektfile  wieder  gelöscht.  In
Zeile  sieben wird übrigens ein zweites Argument benutzt.  Dieses  gibt
den Namen des lauffähigen Programms an (diesmal mit Extension).

Ein Aufruf dieser Batchdatei könnte nun folgendermaßen aussehen:

                 batch cc command command.prg

äquivalent dazu wäre der Aufruf:

                        @cc command command.prg

Es wird also der C-File 'command.c' compiliert und gelinkt.  Der daraus
resultierende  File  soll 'command.prg'  heißen.  Der  zwischenzeitlich
entstehende File 'command.o' wird durch den rm-Befehl gelöscht.
Die  eigentliche Batchdatei heißt 'cc'.  Die Parameterangaben '$0'  und
'$1' werden durch die Argumente 'command' (für '$0') und  'command.prg'
(für '$1') ersetzt.

Das zweite Beispiel dient dem gleichen Zweck, nur soll diesmal im Falle                                     -42-


eines  Fehlers  ein Editor ('editor.prg' genannt) aufgerufen  und  nach
erfolgter  Editierung  wieder  zum  Anfang  der  Batchdatei  gesprungen
werden:

6.3.2 Bsp.2

     ;
     ; Batchfile zur Compilierung und zum Linken eines C-Files
     ; durch den MEGAMAX-C-Compiler
     ;
     mmcc.ttp $0.c         ;Aufruf des Compilers
     ?status# 0 edit       ;Sprung zum Editor, wenn Fehler
     mmlink.ttp $0.o -O $1 ;Aufruf des Linkers
     ?status# 0 edit       ;Sprung zum Editor,wenn Fehler
     rm $0.o               ;Löschen des Objektfiles
     stop                  ;Stoppen des Batchfiles
     lbl edit              ;Label 'edit'
     wait                  ;in aller Ruhe Fehlermeldungen lesen
     editor.prg $0.c       ;Editoraufruf
     restart               ;Neustart des Batchfiles

Die Interpretierung dieses Files dürfte nach den vorhergehenden Ausfüh-
rungen, keine Probleme mehr bereiten.

                                    -43-

6.3.3 Bsp.3

     ;
     ; Batchdatei zur Assemblierung von Sourcefiles
     ; mit dem Assembler aus dem Entwicklungspaket von DRI
     ;
     notext                        ; kein Geschwafel
     cls
     size0 $0.s fehler             ; Sourcefile muß schon da sein
     echo 1. Assemblierung         ; erster Schritt
     as68.ttp -l -u $0.s
     size0 $0.o fehler             ; Ergebnis der Assemblierung
     echo 2. Linken                ; zweiter Schritt
     echo $0.s ==> $0.$1
     link68.ttp [u] $0.68k = $0.o  ; Linken des 'o'-Files
     size0 $0.68k fehler           ; wenn kein Ergebnis -> Fehler
     echo 3. Relativlader
     relmod.ttp $0.68k $0.$1       ; Ergebnis basteln
     rm $0.68k $0.o                ; überflüssige Files löschen
     echo
     stop
     lbl fehler                    ; Fehler melden
     echo !!! Abbruch wegen Fehler !!!
     echo

Mit  diesem File kann die Assemblierung von Files durch  den  Assembler
des Entwicklungspakets automatisiert werden.  Diese Datei benötigt zwei
Argumente,  zum  einen den Namen des Sourcefiles (ohne  '.s'-Extension)
und  zum  anderen die Extension der  Zieldatei,  also  '.PRG',  '.TOS',
'.ACC' oder '.TTP'.
Will  man  z.B.  den  File 'test.s'  assemblieren,  könnte  der  Aufruf
folgendermaßen aussehen:

                             @as test prg

Es wird dabei angenommen,  daß die Batchdatei 'as' heißt. Der Ergebnis-
file würde hier 'test.prg' heißen.


                                    -44-

7 Variablen

Die letzte Steuermöglichkeit eines Batchfiles wird durch die Einführung
der bereits kurz angesprochenen Variablen geboten.
Der  Benutzer  ist in der Lage,  Variablen zu definieren und  kann  mit
diesen einfache Rechnungen durchführen,  Schleifen aufbauen oder  durch
Sprunganweisungen bestimmte Abläufe von Batchdateien erzeugen.
Man  sieht vielleicht hier schon,  daß die Variablen in der  Hauptsache
zum einfacheren Arbeiten mit Batchdateien beitragen sollen.  Viele  der
hier  aufgeführten Kommandos sind nur in solchen Dateien  sinnvoll  und
zulässig!

Die Befehle im einzelnen ('|' bedeutet "entweder oder"):

-> let <var> <zahl | varvalue>
Belegen von 'var' mit dem Wert 'zahl' oder 'value'
BEISPIEL:

                             let index 111

Die Variable 'index' wird mit 111 belegt.

                           let index2 index

Die Variable 'index2' wird mit dem Wert der Variablen 'index' belegt.

-> if <varA> = <varB | zahl> <label>
-> if <varA> <> <varB| zahl> <label>
-> if <varA> > <varB | zahl> <label>
-> if <varA> < <varB | zahl> <label>
Damit  kann in Batchfiles ein fröhliches Hin- und  Hergespringe  veran-
staltet werden.  Die Bedeutung wird wohl durch Beispiele am einfachsten
vermittelt:
BEISPIEL:

                         if index = 22 marke1

Wenn  die  Variable 'index' den Wert 22 hat,  soll zur  Marke  'marke1'
gesprungen werden.

                     if parameter <> index markex

Wenn die Variable 'parameter' ungleich der Variablen 'index' ist,  soll
zur Marke 'markex' gesprungen werden.

                                    -45-

-> -- <variable(n)>
Dekrementieren einer oder mehrerer Parameter um eins.
BEISPIEL:

                             -- index juhu

Die beiden Variablen 'index' und 'juhu' werden um eins erniedrigt.

-> ++ <variable(n)>
Analog zu --, nur daß diesmal eins dazuaddiert wird.

-> -= <varA> <varB | zahl>
Erniedrigen von 'varA' um 'varB' oder 'zahl' oder anders ausgedrückt:

                          varA := varA - varB
                          varA := varA - zahl

'varB'  kann übrigens die gleiche Variable wie 'varA' sein.  In  diesem
Falle würde das bedeuten,  daß 'varA' nach der Operation den Wert  Null
hat.
BEISPIEL:

                              -= index 12

Von der Variablen 'index' wird 12 abgezogen.

                             -= index juhu

Von  der Variablen 'index' wird der Wert des Parameters 'juhu'  abgezo-
gen.

-> += <varA> <varB | zahl>
Analog zu -=, nur daß diesmal eine Addition stattfindet.

-> *= <varA> <varB | zahl>
Analog zu -=, nur daß diesmal eine Multiplikation stattfindet.

-> /= <varA> <varB | zahl>
Analog zu -=, nur daß diesmal eine Division stattfindet.

-> 2* <variable(n)>
Verdoppeln von Variablenwerten.
                                    -46-

BEISPIEL:

                             2* index juhu

'index' und 'juhu' haben hier ihre Werte verdoppelt.

-> 2/ <variable(n)>
Halbieren von Variablenwerten.
Da  die  Variablen  vom Typ Integer  sind,  werden  ungerade  Variablen
natürlich  nicht den korrekten Wert erhalten,  11 / 2 würde im  Wert  5
resultieren und nicht in 5.5!
BEISPIEL:

                               2/ index

Hat  'index' vor Ausführung des Kommandos 222 enthalten,  steht  danach
111 in der Variablen.

-> print <variable(n)>
Ausgabe der Variablenwerte auf dem Bildschirm.
BEISPIEL:

                           print index juhu

Hier werden die Inhalte von 'index' und 'juhu' ausgegeben.

-> clear
Alle Variablenwerte werden auf Null gesetzt,  d.h.  aber nicht, daß die
Variablenliste entfernt wird, dafür gibt es das folgende Kommando:

-> erase
Die Variablenliste wird entfernt.

-> vardump
Alle  vorhandenen Variablen werden mit ihren Werten auf den  Bildschirm
ausgegeben.  Dieser  Befehl verschafft dem Benutzer immer  einen  Über-
blick,  welche  Variablen existieren,  wie groß ihre  Anzahl  ist,  mit
welchen  Werten  sie  gerade  belegt  sind  und  wo  sie  sich  in  der
Variablenliste befinden.


7.1 Allgemeines zu den Variablen

Alle Variablen sind vom Typ Longinteger (32 Bits).
Neue Variablen können nicht nur durch den let-Befehl eingeführt werden.
Jeder Bezug auf eine Variable,  die noch nicht existiert, erzeugt einen                                     -47-


Variableneintrag und setzt den aktuellen Variablenwert auf Null!

Die Variablen sind in einer Pointerliste, die den jeweiligen Variablen-
namen und Wert enthält, organisiert.


7.2 Beispiel

An  einem  Beispiel soll gezeigt werden,  daß mit Hilfe  der  Variablen
nicht nur Zählschleifen in Batchfiles aufgebaut werden können.

Der folgende Batchfile dient zur Compilierung,  Linkung und Codeverbes-
serung  der einzelnen Sourcefiles,  aus denen  der  Kommandointerpreter
besteht.
Die Sourcefiles heißen im einzelnen 'COMMAND.C', 'COM.C' und 'EDI.C'.
Die Batchdatei soll nun in der Lage sein,  jeden einzelnen dieser Files
zu  compilieren oder den Objektcode zu verbessern.  Zusätzlich muß  die
Möglichkeit gegeben sein, die entsprechenden Objektfiles zusammenlinken
zu können, so daß command.prg als Endprodukt entsteht.
Jede  dieser  Anforderungen  muß über  Parametereingabe  an  die  Datei
einzeln erfüllt sein.
Das Eingabeformat soll folgendermaßen aussehen:

                          @cc <file> [aktion]

'cc'  repräsentiert  dabei die Batchdatei.  <file> ist einer  der  oben
genannten Files (ohne Extension!).  [aktion] steuert das Verhalten  des
Batchfiles. Wird dieser Parameter weggelassen, soll der angegebene File
compiliert werden.  Daran anschließend eine Code-Verbesserung  durchge-
führt werden und zum Schluß das ganze zusammengelinkt werden.
Wird  für  [aktion] 'lc' oder 'cl' eingegeben wird,  nur  der  Compiler
gestartet und das ganze zusammengelinkt.
Bei Eingabe von 'il' oder 'li' wird eine Code-Verbesserung durchgeführt
und dann der Linkvorgang gestartet.
'l' resultiert in einem Linkvorgang.
'c' startet nur den Compiler.
'i' führt eine Codeverbesserung aus.

Möchte  man den File 'COMMAND.C' compilieren und mit den anderen  Files
zusammenlinken, müßte also

                            @cc command lc

eingegeben werden.

                                    -48-

7.2.1 Der File cc

     ;
     ; Batchfile zur Compilierung eines C-Files von command.prg
     ;
     notext         ; keine Kommandoausgabe auf Schirm
     cls
     ;
     ; Steuervariable
     ;
     let $1 0            ; alles ausführen
     let lc 4            ; compilieren und linken
     let cl 4            ; - " -
     let l 1             ; linken
     let c 2             ; compilieren
     let i 6             ; Code verbessern
     let il 5            ; verbessern und linken
     let li 5            ; - " -
     if $1 = 1 linken
     if $1 > 4 improve
     mmcc.ttp $0.c       ; Compilerabteilung
     ?status# 0 exit     ; im Fehlerfall
     if $1 = 2 exit      ; nur Compilerlauf
     if $1 = 4 linken
     lbl improve         ; Improve-Abteilung
     mmimp.ttp $0.o
     ?status# 0 exit     ; Fehler aufgetreten
     if $1 = 6 exit
     lbl linken          ; Linkerabteilung
     mmlink.ttp command.o com.o edi.o -O command.prg
     lbl exit

Ich glaube,  damit ist eine sinnvolle Verwendung für Variablen deutlich
geworden.
Es ist relativ einfach,  diesen File an eigene Bedürfnisse  anzupassen.
Die Vorgehensweise dürfte keine großen Verständnisprobleme aufwerfen.


                                    -49-

8 EDI

EDI ist ein zeilenorientierter (Primitiv-) Editor.  Er soll zum schnel-
len  Modifizieren  von Kleinigkeiten in  Batchfiles  o.ä.  dienen.  Zum
Schreiben von Programmen oder zum Betreiben von Textverarbeitung sollte
man einen anderen Editor verwenden (z.B. TEMPUS, EMACS u.s.w.).
Der  Vorteil  dieses eingebauten Programmteils liegt in  der  schnellen
Verfügbarkeit;  Ladezeiten,  wie sie für die Verwendung eines  externen
Editors benötigt werden, entstehen nicht.
Der Aufruf erfolgt mit "edi <filename>".
Jede  eingelesene  Zeile darf höchstens 76 Zeichen  lang  sein!  Kommen
längere Zeilen vor, erfolgt ein Stutzen der Zeile (ohne Warnung!).
Tabulatorzeichen werden in Blanks umgewandelt (daran kann man erkennen,
wie einfach der Editor ist)!
Bei Angabe eines nichtexistenten Files,  wird dieser bei Verlassen  von
EDI  (via  's') erzeugt.  Es wird keine Warnung  ausgegeben,  daß  eine
nichtvorhandene Datei angegeben worden ist!


8.1 Die Kommandos von EDI

Es  gilt jeweils der in die Hochkommas eingeschlossene  Buchstabe,  die
RETURN-Taste wird zum Abschließen der Eingabe nicht benutzt!


'e'(dit) Editieren einer Zeile
Nach  Eingabe von 'e' wird eine Zeilennummer angefordert.  Das  eigent-
liche Editieren geht genau wie bei der Eingabe von Kommandos,  also mit
den Cursortaste u.s.w.  Sollen eingegebene Änderungen nicht  übernommen
werden, kann mit ^Z ein Abbruch des Kommandos durchgeführt werden.

'l'(ist) Auflisten des eingelesenen Files
Es wird nach Eingabe von 'l' der gewünschte Zeilenbereich  angefordert.
Wird bei 'START:' einfach nur RETURN gedrückt,  erfolgt ein  komplettes
Auflisten des Files.
Ein vorzeitiges Abbrechen des Listvorgangs ist mit ^Z möglich.
F1 unterbricht die Ausgabe, mit F1 wird wieder fortgefahren.

'p'(rint) Printerausgabe
Der  analoge Befehl zu 'list'.  Die Ausgabe erfolgt allerdings auf  den
Drucker.
Die  Druckerinformationen  und Einstellungen  des  lp-Kommandos  werden
nicht berücksichtigt!  Es handelt sich wirklich nur um eine  Ausgabeum-
leitung des 'list'-Befehls.

                                    -50-

'f'(ind) Stringsuche
Sucht nach einem bestimmten String innerhalb von Zeilen. Jede Zeile, in
der der einzugebende String vorkommt, wird ausgegeben.

'r'(eplace) Stringersetzung
Es  muß  dabei  angegeben werden,  ob vor  dem  Ersetzungsvorgang  eine
Sicherheitsabfrage erfolgen soll oder nicht.

'd'(elete) Zeilenlöschen
Es wird der zu löschende Bereich angefordert.

'i'(nsert) neue Zeilen einfügen
Es  wird  die Nummer der Zeile angefordert,  vor der die  neuen  Zeilen
eingefügt werden sollen. Abbruch dieses Modus mit ^Z.

'a'(ppend) Zeilenanfügen
Anfügen von neuen Zeilen an das Fileende. Abbruch wie immer mit ^Z.

'n'(ew) Gesamtlöschung
Löscht alle Zeilen. Es findet allerdings eine Sicherheitsabfrage statt.

's'(ave) Abspeichern
Abspeichern des Files und verlassen von EDI.

(e)'x'(it) Beenden
Verlassen von EDI ohne abspeichern.

'h'(elp) Hilfe
Auflisten  der vorhandenen Befehle mit einer kurzen Beschreibung  sowie
Angabe des aktuellen Files.


                                    -51-

9 Fehlermeldungen

Der  Interpreter gibt zahlreiche Fehlermeldungen aus.  Diese sind  hier
mit einer kurzen Beschreibung zusammengefaßt. Man darf allerdings nicht
erwarten, daß command.prg Korrekturvorschläge macht.

«missing argument(s)»
Fehlernr.:1
Es gibt halt Befehle,  die erwarten einfach ein Argument oder wenn  sie
ganz unverschämt sind, gleich mehrere.

«directory isn't empty»
Fehlernr.:2
Hier wurde versucht, ein nicht leeres Verzeichnis zu löschen.

«can't delete directory»
Fehlernr.:3
Man sollte nur Ordner entfernen, die es auch wirklich gibt.

«wrong commandsyntax or argument»
Fehlernr.:4
Kann  bei  der  Zahlenkonvertierung auftauchen oder  wenn  Befehle  mit
unpassenden Argumenten versorgt werden.

«printer not connected»
Fehlernr.:5
Entweder Printer online stellen oder das Ding einfach mal einschalten.

«can't open file»
Fehlernr.:6
Passiert, wenn ein File nicht gefunden werden kann.

«can't delete file»
Fehlernr.:7
Kommt vor,  wenn rm es nicht schafft einen File zu löschen.  Zum  einen
passiert dies,  wenn es den File nicht gibt,  zum anderen kann der File
auch vor Löschen geschützt sein.

«command not found»
Fehlernr.:8
Kann eine Eingabe nun überhaupt nicht verarbeitet werden,  kommt  diese
Meldung.

«too many arguments»
Fehlernr.:9
Manche  Befehle  wollen  überhaupt  kein  Argument,   andere  nur  eine                                     -52-


bestimmte Anzahl. Bei Überfütterung stößt man dann auf diese Meldung.

«argument out of range»
Fehlernr.:10
Wird  ausgegeben,  wenn beim time-Kommando bzw.  beim  date-Befehl  ein
fehlerhaftes Argument angegeben worden ist.

«too much batch-files»
Fehlernr.:11
Es dürfen maximal drei Batchdateien geöffnet sein.

«use only in batch-files»
Fehlernr.:12
Es gibt Kommandos die nur dort Sinn haben (z.B. restart).

«label not found»
Fehlernr.:13
Eine Marke konnte nicht gefunden werden.

«can't create file»
Fehlernr.:14
Es war,  aus was für Gründen auch immer,  nicht möglich,  einen File zu
erstellen.

«wrong directory»
Fehlernr.:16
Kommt beim Wechsel in einen nicht vorhandenen Ordner vor.

«don't use '*' or '?'»
Fehlernr.:17
Kommt bei einigen Befehlen vor,  die sich nur auf Einzelfiles  anwenden
lassen (z.B. hide).

«can't execute '.acc'-files»
Fehlernr.:18
Der Interpreter ist nicht in der Lage, Deskaccessories auszuführen.

«directory exists»
Fehlernr.:19
Ein Ordner kann nicht zweimal gebastelt werden.

«can't create directory»
Fehlernr.:20
Aus  irgendwelchen  Gründen  kann die  Kreierung  eines  Ordners  nicht
vorgenommen werden (z.B. Schreibschutz).
                                    -53-


«'!'-argument not in range»
Fehlernr.:21
Es wurde versucht auf einen alten Befehl zuzugreifen,  der nicht in der
History-Liste ist.

«relation unknown»
Fehlernr.:22
Problemchen bei den if-Bedingungen in der Variablenabteilung.

«not enough disk-space»
Fehlernr.:23
Bedeutung dürfte klar sein.

«file not open»
Fehlernr.:24
Das  write-Kommando  wurde  angewandt,  obwohl  gerade  kein  File  mit
open/append geöffnet worden ist.
Durch das Wegfallen dieser Befehle, gibt es diese Meldung nicht mehr!

«can't change mode»
Fehlernr.:25
Findet beim chmod-Befehl Verwendung.


Die Fehlernummer 15 existiert nicht mehr, deshalb die Lücke!

Es gibt einige Fehler, die zum sofortigen Programmstop des Interpreters
führen.  Sollte es nicht mehr möglich sein, RAM-Platz für Einträge, wie
z.B.  die History-Liste oder ALIAS,  zu beschaffen,  tritt ein  solcher
Abbruch auf.

Das Programm wird übrigens gar nicht erst gestartet, wenn der Reservie-
rungsversuch des Interpreters,  der sich 32k RAM besorgen  will,  fehl-
schlägt.  Man  sollte  dann seine RAM-Disk etwas  kleiner  machen  oder
einige Accessories entfernen.

Ist ein Fehler aufgetreten enthält status die Fehlernummer.


                                    -54-

10 Die Ausgabeumleitung

Einige Befehle erlauben es,  die Ausgabe in einen File umzuleiten. Dazu
muß direkt an das Kommando '|[file]' mit angegeben werden.
BEISPIEL:

                             tree|dir.txt

Das Directoryverzeichnis wird in den File 'dir.txt' geschrieben.

Folgende Kommandos sind mit der Umleitung ausgestattet:

          - tree    - time    - print   - cp      - wc
          - find    - date    - status  - alias   - pwd
          - od      - cat     - flags   - df
          - dir     - more    - version - device
          - ls      - echo    - cmp     - head
          - string  - vardump - help

Wird die Umleitung bei Kommandos angewandt, die diese Möglichkeit nicht
bieten, wird ein leerer Ausgabefile erzeugt, sonst passiert nichts!
Unangenehm wird es allerdings wenn,  z.B.  mit od,  ein Ausgabefile vom
Ausgabefile gemacht werden soll. Der File geht dann nämlich verloren!
Bei  Angabe  von  '|[file]' wird eine neue  Datei  erstellt,  gibt  man
hingegen '||[file]' an, erfolgt die Umleitung an das Ende einer bereits
bestehenden  Datei.  Existiert diese allerdings noch nicht,  wird  eine
neue kreiert (Funktion dann wie ein '|[file]').
Es kann übrigens auch auf Gerätschaften ausgegeben  werden.  'dir|PRT:'
sendet z.B. seine Ausgabe zum Druckerport (Centronics-Schnittstelle).

     PRT:      Umleitung zum Drucker
     CON:      Umleitung zur Konsole (entspricht keiner Angabe)
     AUX:      zur RS-232 Schnittstelle (nicht getestet!)
     MIDI      (nicht getestet)

                                    -55-

11 Allgemeines Blabla zum Schluß

11.1 Lieferumfang

- COMMAND.PRG
  der eigentliche Interpreter.

- COMMAND.TXT
  die vorliegende Beschreibung.

- COMMAND.HLP
  wird für den help-Befehl gebraucht.

- TEST
  ein Batchfile, der zur Funktionsüberprüfung der meisten Komman-
  dos  dienen  soll.  Man  kann  anhand  dieser  Datei  auch  die
  Funktionsweise der diversen Befehle recht gut erkennen.

- GETARG.PRG
  ein kleines Programm,  das zur Ermittlung der Parameter  dienen
  soll,  die  an  ein Programm z.B.  durch eine  Shell  übergeben
  werden.  Damit  lassen sich verschiedene  Anwendungen,  in  der
  Hauptsache allerdings Compiler und Linker,  an den  Interpreter
  anpassen.
  GETARG.PRG  muß nur in den entsprechenden  Programmnamen  umge-
  nannt werden, dann einfach den normalen Funktionsablauf starten
  und schon kann man erkennen, welche Parameter übergeben werden.

- CC
  ein Beispielbatchfile,  der zur Compilierung und Linkung von C-
  Files  unter Verwendung des MEGAMAX-C-Compilers benutzt  werden
  kann.  Tritt  ein  Fehler  auf,  wird  automatisch  ein  Editor
  aufgerufen,  dieser  muß vom Benutzer definiert  werden  (siehe
  Batchdatei).

- AS
  dieser Batchfile entspricht dem Beispiel 3, daß ich weiter oben
  gegeben  habe.  Damit  lassen  sich  Assemblerfiles  durch  den
  Assembler  und Linker aus dem Entwicklungspaket zu  lauffähigen
  Programmen übersetzen.



11.2 Zur Programmierung

Programmiert  wurde das ganze Ding mit dem  MEGAMAX-C-Compiler  (V1.1).                                     -56-


Eine  ganze Menge von dem Code ist allerdings in Assembler  geschrieben
(Inlineassembler vom MEGAMAX).
Als Programmeditor wurde,  in der Hauptsache,  der MicroEMACS  benutzt.
Der ist zwar nicht gerade berühmt,  was Geschwindigkeitsrekorde angeht,
aber  sonst ziemlich mächtig (vor allem verarbeitet er auf  eine  recht
vernünftige Art und Weise Tabulatoren).
Inzwischen  bin  ich  allerdings wegen der Größe  der  Sourcefiles  auf
TEMPUS umgestiegen,  vielleicht kommt ja sogar mal eine Version, die es
auch erlaubt, die Tabulatortaste zu verwenden.

Im  Laufe  der  Zeit sind immer wieder  Neuerungen  und  Verbesserungen
dazugekommen.  Leider haben sich viele Verbesserungen in der Folge eher
als  Verschlimmbesserungen  entpuppt.  Um diesem  Umstand  Rechnung  zu
tragen, habe ich den File test gebastelt, der die meisten Kommandos auf
ihre Funktionsfähigkeit hin überprüft.

Bei der Arbeit mit dem Programm kann es vorkommen,  daß man auf  Fehler
stößt.  Eine  ganze Menge sind seit der Version 1.04  entfernt  worden,
aber  ich fürchte,  daß es doch noch einige gibt.  Ein paar der  Fehler
liegen im Betriebssystem, an denen kann ich leider nicht viel ändern.

Ob es mit dem neuen TOS Probleme geben wird, bleibt noch abzuwarten.
Theoretisch  dürfte  dies eigentlich nicht der Fall sein,  da  ich  nur
offizielle Routinen bzw.  Systemaufrufe benutzt habe, eigentlich müßten
bei  einer  fehlerfreien  neuen TOS-Version auch  einige  Probleme  des
Interpreters verschwinden.
Wenn  man aber die Geschwindigkeit sieht,  mit der ATARI die neue  TOS-
Version der Öffentlichkeit zugänglich macht,  brauche ich mir hier wohl
weder  graue  Haare  wachsen  zu  lassen  noch  sollte  man  großartige
Hoffnungen hegen.
Da es scheinbar keine offiziellen Angaben darüber gibt, welche Register
bei  GEMDOS/XBIOS/BIOS-Aufrufen verändert werden,  habe  ich  dort,  wo
solche  Aufrufe  im Programm vorkommen,  die Register D2-D7  und  A2-A6
gerettet. In der Hoffnung, daß mir dabei kein Fehler unterlaufen ist...
Da  MEGAMAX für Funktionen wie z.B.  getc() oder fopen() wohl auch  auf
diese  Aufrufe  aufbaut,  gehe ich mal davon aus,  daß  die  Entwickler
dieses Compilers die notwendigen Register retten.

Nach  der Abarbeitung von externen Programmen werden nun einige  Zeiger
wieder restauriert (z.B. für die Mausroutinen). Damit haben sich einige
Probleme, die durch die Zeigerverbiegerei, ausgelöst durch irgendwelche
Programme, entstanden sind, in Luft aufgelöst.
Trotzdem  gibt  es immer noch Programme,  die sich gar  nicht  mit  dem
Interpreter  vertragen;  bis jetzt ist mir der entscheidende  Gedanken-
blitz zur Beseitigung dieser Restriktion noch nicht gekommen.
Sauber programmierte Anwendungen laufen aber klaglos.                                    -57-



An  dem Programm erhebe ich von meiner Seite keinerlei Copyrights  oder
ähnliche Ansprüche , es kann von jedem beliebig genutzt und weitergege-
ben werden.
Natürlich  wäre  es  recht nett,  wenn  bei  einer  solchen  Weitergabe
wirklich alle Files dabei sind, das Programm ist z.B. ohne ausreichende
Beschreibung nicht allzuviel wert.

Interessenten  am  Sourcecode  können  diesen  gegen  Einsendung  einer
Leerdiskette und eines frankierten Rückumschlags bekommen.
Da  ich an dem Programm immer noch Änderungen durchführe (neue  Befehle
einbauen,  Fehler entfernen ...), enthält diese Sourcecodediskette dann
auch die jeweils neueste Version, sowie einige Utility-Programme.
Diese  Sourcecode-Kopie  kostet  natürlich nichts  (außer  dem  bereits
erwähnten Porto,  der Verpackung und der Diskette); es sollten für mich
einfach, außer der Zeit, keine Kosten entstehen.

Anregungen,  Fragen und vor allem Meldungen von aufgetretenen Programm-
fehlern bitte ich an mich zu schicken:

                         Joachim Wolf
                         Heubergstr. 3
                    7014 Kornwestheim
                    Tel.:[phone]


                                    -58-

12 ANHANG A (Befehlszusammenfassung)

!              Zugriff auf altes Kommando
#              Dezimalwert umrechnen
$              Hexwert umrechnen
*=             Variablenmultiplikation
++             Variable inkrementieren
+=             Variablenaddition
--             Variable dekrementieren
-=             Variablensubtraktion
/=             Variablendivision
2*             Variable verdoppeln
2/             Variable teilen
;              Kommantarzeile
<              Statusabbruchbedingung
<>             Statusabbruchbedingung
==             Statusabbruchbedingung
>              Statusabbruchbedingung
?arg           Sprung zu Label, wenn Argument existiert
?batch         zeigt Anzahl offener Batchdateien
?ok            Virusüberprüfung
?status#       status-Sprungbedingung
?status<       status-Sprungbedingung
?status=       status-Sprungbedingung
?status>       status-Sprungbedingung
?stop          bedingt Batchfile stoppen
@              Batchfile aufrufen
\              Oktalwert umrechnen
alias          Belegungen ausgeben
batch          Batchfile aufrufen
bell           einmal klingeln
break          Abbruch der Batchbearbeitung
cat            File(s) ausgeben
cd             Ordner wechseln
chmod          Fileattribute ändern
clear          Variablenwerte löschen
cleararg       löscht vorhanden $-Argumente
cls            Bildschirm löschen
cmp            Filevergleich
compress       Filekomprimierung
cp             File(s) kopieren
crsoff         Cursor ausschalten
crson          Cursor einschalten
crypt          Fileverschlüsselung
date           Datum ausgeben/setzen
defkey         Funktionstaste belegen                                    -59-


delalias       Alias-Eintrag entfernen
device         Ausgabe der ansprechbaren Massenspeicher
df             Speicherplatz auf Diskette
dir            File(s) auflisten
echo           String ausgeben
edi            Editor aufrufen
erase          Variablenliste entfernen
errorbreak     Batchabbruch im Fehlerfall
exist          Test ob File vorhanden
exit           Interpreter verlassen
expand         komprimierte Files expandieren
find           File(s) finden
flags          Flagausgabe
free           freier RAM-Bereich
getalias       Belegungen einlesen
goto           Sprung zu Marke
h              verfügbare alte Eingaben auflisten
head           die ersten zehn Zeilen eines Files ausgeben
help           Hilfefunktion
hide           File verstecken
history        verfügbare alte Eingaben auflisten
if ... <       Variablensprung
if ... <>      Variablensprung
if ... =       Variablensprung
if ... >       Variablensprung
ifarg          Sprung, wenn zwei Strings gleich
inverse        Bildschirmdarstellung umschalten
keyboard       Ausgabe Tastenbedeutungen
keys           Ausgabe der Funktionstastenbelegungen
lbl            Marke setzen
let            Variable belegen
lock           Rechner sperren
lp             File(s) ausdrucken
lpmargin       linker Rand bei Listings
lppage         Anzahl der Seite pro Seite bei Listings
ls             File(s) auflisten
merge          Files verbinden
mkdir          neuen Ordner
more           File(s) ausgeben
mouseoff       Mauszeiger ausschalten
mouseon        Mauszeiger einschalten
mv             File umbenennen
newalias       Neubelegung einführen
notext         Batchkommandos nicht ausgeben
numbers        bei Listings Zeilennummer ausgeben ein/aus
od             Filedump                                    -60-


oldy           wenn File 1 älter ist als File 2, dann gehe zu Label
page           Listings mit Seitennummern versehen
path           Angabe eines Suchpfades
pchange        bei path-Befehl Ordnerwechsel ein/aus
print          Variablenwert ausgeben
pwd            Ausgabe des aktuellen Pfades
reset          Rechner zurücksetzen
resetlp        Printerinitialisierung
restart        an Batchfileanfang springen
rm             File(s) löschen
rmdir          Ordner löschen
save           File(s) nur lesbar
savealias      Belegungen abspeichern
setarg         setzen von $-Argumenten
savehist       history.dat abspeichern ein/aus
setlp          Printerinitialisierung
settab         Tabulator setzen
shiftarg       verschieben von $-Argumenten
size0          Test, ob File nicht vorhanden
slash          '/' -> '\' ein/aus
srhist         History ein/aus
srtab          automatische Tabulatorfunktion aus-/einschalten
srtitle        Titelseitenausgabe ein/aus
status         Status ausgeben
stop           Batchfile stoppen
string          Stringsuche
sz             Ausgabe Beta ein/aus
text           Batchkommandos ausgeben
time           Zeit ausgeben/setzen
tree           Ordnerstruktur auflisten
unsave         File(s) les- & schreibbar
vardump        Variable ausgeben
version        Erstellungsdatum ausgeben
wait           auf Tastendruck warten
wc             Zeilen & Ziffern zählen

Ich hoffe,  daß ich in diese Liste alle vorhandenen Befehle aufgenommen
habe.
Sie soll lediglich als Gedankenstütze dienen!  Die vollständige  Syntax
zu  einem  bestimmten  Befehl ist  den  vorangehenden  Ausführungen  zu
entnehmen.
Im  Anhang  findet  sich ein Index,  der ein  schnelles  Auffinden  der
gesuchten Kommandos ermöglicht.


                                    -61-

13 ANHANG B (oldy-Beispiele)

13.1 Beispiel 1 für die Verwendung des oldy-Befehls

          let kontrolle 3
          size0 command.o compiliere1
          oldy command.o command.c compiliere1
          lbl com
          size0 com.o compiliere2
          oldy com.o com.c compiliere2
          lbl edi
          size0 edi.o compiliere3
          oldy edi.o edi.c compiliere3
          lbl linke
          if kontrolle = 3 ende
          link command.o com.o edi.o -O command.prg
          lbl ende
          stop
          lbl compiliere1
          cc command.c
          <> 0
          imp command.o
          -- kontrolle
          goto com
          lbl compiliere2
          cc com.c
          <> 0
          imp com.o
          -- kontrolle
          goto edi
          lbl compiliere3
          cc edi.c
          <> 0
          imp edi.o
          -- kontrolle
          goto linke

Das  Beispiel  bezieht sich wieder auf die drei Teile,  aus  denen  der
Kommandointerpreter besteht.
Der  Batchfile überprüft das Vorhandensein der  Objektfiles  bzw.  wenn
diese vorhanden sind,  ihr Alter.  Sind sie nicht vorhanden oder  älter
als der zugehörige Sourcecode, wird ein Compilerdurchgang gestartet.

Das zweite Beispiel soll zeigen,  daß bei Verwendung anderer  Kommandos
eine gewisse Platzersparnis zu erzielen ist:
                                    -62-


13.2 oldy, die Zweite

     setarg command com edi             ;die Quelldateien
     lbl loop                           ;Compilerabteilung
     size0 $0.c weiter                  ;Sourcefile fehlt
     size0 $0.o compiliere              ;Objektfile fehlt
     oldy $0.o $0.c compiliere          ;Alter überprüfen
     goto weiter                        ;nächsten File
     lbl compiliere                     ;eigentliche Compilierung
     cc $0.c
     <> 0                               ;raus wenn Fehler
     imp $0.o                           ;Codeimprover
     lbl weiter
     shiftarg                           ;nächste Datei
     ?arg 0 loop                        ;wenn noch eine da ist
     ; sonst Ende
     link command.o com.o edi.o -O command.prg  ;das Ergebnis


Ich hoffe,  diese Beispiele verdeutlichen die Möglichkeiten,  die  oldy
bietet.
Man kann damit zwar keine Super-MAKE-Umgebung erstellen, aber Kleinvieh
macht auch Mist und aufgrund der Einfachheit in der  Benutzung,  sollte
jeder,  der öfters Programme erstellt, deren Sourcecode mehrere Dateien
umfaßt,  in  der Lage sein,  einen nicht unerheblichen Nutzen  aus  dem
Kommando ziehen zu können.


                                    -63-

14 Index

! ................... 31f,32ff,33ff,53,58
!! .................. 33f
# ................... 28
$ ................... 28
*= .................. 45,58
++ .................. 45,58
+= .................. 45,58
-- .................. 45f,58,61f
-= .................. 45ff,58
/ ................... 11,21,25f,26,28,60
/= .................. 45,58
2* .................. 45,46,58
2/ .................. 46f,58
< ................... 40,59
<> .................. 39,41f,44f,59,61f,62
= ................... 59
== .................. 40,43,58
> ................... 40,59
?arg ................ 36f,39,58,62
?batch .............. 36,58
?ok ................. 7,58
?status ............. 40ff,42f,48f,58ff
?stop ............... 36,58
@ ................... 35f,41,43,47f,58
ALIAS ............... 53
Alias ............... 29f,30f,59
Ausgabeumleitung .... 27
BACKSPACE ........... 4
Batch ............... 3,7,14,29,30,34ff,35ff,36ff,37ff,38ff,39ff,40ff,
                      41ff,42ff,43f,44ff,47ff,48,49,52,55f,58ff,59f,
                      60f,61
Bildschirm .......... 7,9,14,17f,19f,20,33,36,46f,58,59
CONTROL ............. 4f
CONTROL-D ........... 4
CONTROL-X ........... 4
CURSOR-DOWN ......... 32,33
CURSOR-UP ........... 32,33
DELETE .............. 4
Directory ........... 8,11,19,22,24,54
Drucker ............. 17f,18,23f,24f,25f,26f,49f,54f
EMACS ............... 49,56
ESC ................. 4f
Fileattribut ........ 8,13,58
Funktionstaste ...... 7,13f,17,58,59                                    -64-


HELP ................ 16
History ............. 3f,25f,31f,32f,33,34,53f,60
INSERT .............. 4
Kommandointerpreter . 3,29,47,61
Laufwerk ............ 5,7,8ff,9,10,11ff,13f,14,15f,19,21f,22f,23,26,
                      27f,28
MEGAMAX-C ........... 41f,42,55f
MS-DOS .............. 3
Maus ................ 3,19f,20ff,56,59f
Ordner .............. 4,5,7,8f,9f,11,13f,14,16,18ff,21,22,24f,26f,51,
                      52f,58,59,60f
SHIFT ............... 4f,13
TAB ................. 25f
TEMPUS .............. 49,56
UNIX ................ 3,31
VMS ................. 3,32,35
Variable ............ 38f,44ff,45ff,46ff,47ff,48,53,58ff,59ff,60f
Verzeichnis ......... 4,5f,7f,8f,9,11ff,13,14f,15,16,18f,19,21f,23,26,
                      29,40,51
\ ................... 8,11f,21,25f,28f,58,60
alias ............... 29ff,30f,54,58
append .............. 27,53
auto.com ............ 40
batch ............... 34,35ff,41,52f,58
bell ................ 7,58
break ............... 36,58
cat ................. 7ff,19f,24,54,58
cd .................. 7,8ff,18,19,25,27,58
chmod ............... 8,9f,16,17,53,58
clear ............... 46,58
cleararg ............ 39,58
close ............... 27
cls ................. 9,43,48,58
cmp ................. 9,10f,32ff,54,58
command.hlp ......... 16
command.prg ......... 3f,29f,35,40,41ff,47,48f,51,61,62
compress ............ 10f,14f,58
counter ............. 34f
cp .................. 6,11ff,32ff,54,58
crsoff .............. 11,58
crson ............... 11,58
crypt ............... 11,12f,58
date ................ 12f,52,54,58
defkey .............. 13f,17,58
delalias ............ 29,59
device .............. 13,54,59                                    -65-


df .................. 13,54,59
dir ................. 4,13f,14ff,16f,18,19,54f,59
echo ................ 14f,35ff,37f,39f,43ff,54,59
edi ................. 48,49,59
erase ............... 46,59
errorbreak .......... 15,37f,59
exist ............... 37ff,59
exit ................ 14,48ff,59
expand .............. 10f,14,59
find ................ 14,15f,54,59
flags ............... 15,20,22,23,24f,25ff,26,36,37,54,59
free ................ 15,59
getalias ............ 29,59
goto ................ 37f,59,61f,62
h ................... 33,59
head ................ 16f,54,59
help ................ 16f,54,55,59
hide ................ 16f,52,59
history ............. 33f,59
if .................. 44ff,48ff,59ff,61
ifarg ............... 39,59
inquire ............. 39f
inverse ............. 17f,59
keyboard ............ 17,59
keys ................ 17,59
lbl ................. 37ff,39,42,43,48f,59,61ff,62f
let ................. 44f,46,48ff,59,61
lock ................ 17f,59
lp .................. 17f,18,23f,25,49,59
lpmargin ............ 15,18,59
lppage .............. 15,18,59
ls .................. 18f,54,59
merge ............... 18f,59
mkdir ............... 18,19,59
more ................ 19f,24,54,59
mouseoff ............ 19,20,59
mouseon ............. 20f,59
mv .................. 20f,59
newalias ............ 30f,59
notext .............. 15,36,43,48,59
numbers ............. 15,20,59
od .................. 20,21f,54f,59
oldy ................ 38,60,61ff,62f
open ................ 27,53
page ................ 15,21,60
path ................ 5,21f,22ff,60f                                    -66-


pchange ............. 15,21,22,60
print ............... 46f,54,60
pwd ................. 22,54,60
reset ............... 22,60
resetlp ............. 15,18,23ff,24,60
restart ............. 36,42,52,60
rm .................. 16,23ff,41f,42,43,51,60
rmdir ............... 24f,60
save ................ 23,24,27,60
savealias ........... 29,30f,60
savehist ............ 15,24,60
setarg .............. 39ff,60,62
setlp ............... 15,18,24f,60
settab .............. 15,18,24f,60
shiftarg ............ 38,39,60,62
size0 ............... 37f,43f,60,61f,62f
slash ............... 15,25f,60
srhist .............. 15,25f,60
srtab ............... 15,25,60
srtitle ............. 15,18,25f,60
status .............. 38ff,39,40ff,53,54,58ff,60
stop ................ 36f,42,43,60,61
string .............. 25,26f,54,60
sz .................. 15,26,60
text ................ 15,36f,60
time ................ 26f,52,54,60
tree ................ 26,54f,60
unsave .............. 23,24f,27,60
vardump ............. 46,54,60
version ............. 27,54,60
wait ................ 36,42,60
wc .................. 27,54,60
write ............... 27,53